This is the mail archive of the
gdb-patches@sourceware.cygnus.com
mailing list for the GDB project.
Linux threads patch for GDB 4.18
- To: gdb-patches@sourceware.cygnus.com
- Subject: Linux threads patch for GDB 4.18
- From: Jim Kingdon <kingdon@redhat.com>
- Date: Thu, 19 Aug 1999 11:40:01 -0400
After more work than I expected (of the "track it down and tweak it"
variety), I have finally come up with a threads patch for GDB 4.18 (on
Linux) that I'm happy with (at least for now). This isn't news to GDB
maintainers, since you are the ones who sent me this code, but I'm
sending it to this list in case it is helpful to people such as those
building Linux distributions.
I'd encourage people to try this out (either via this patch or the RPM
package gdb-4.18-3 which should be in Rawhide either now or shortly -
see http://developer.redhat.com/ for more on Rawhide and our
bug-tracking system and what-not).
1999-08-13 Jim Kingdon <http://developer.redhat.com/>
Threads code from gdb 4.18-codefusion-990706:
* infrun.c (signal_stop_update, signal_print_update,
signal_pass_update): new functions.
* inferior.h: new prototypes for above functions.
* target.h (enum strata): add thread stratum.
* linuxthreads.c: new file. Support for debugging linux threads.
* config/i386/nm-linux.h: several new prototypes for above.
* config/i386/linux.mh: add linuxthreads.o to NATDEPFILES.
More threads code from the same place:
* config/i386/tm-linux.h (REALTIME_LO, REALTIME_HI): Add
definitions.
* target.h (enum target_signal): Add TARGET_SIGNAL_REALTIME_32.
* target.c (signals, target_signal_from_host,
target_signal_to_host): Add clauses for
TARGET_SIGNAL_REALTIME_32.
* various files: various minor changes to make the above work
with GDB 4.18.
diff -Ncr /home/kingdon/work/gdb/gdb/config/i386/linux.mh ./gdb/config/i386/linux.mh
*** /home/kingdon/work/gdb/gdb/config/i386/linux.mh Thu Apr 15 21:34:19 1999
--- ./gdb/config/i386/linux.mh Fri Aug 13 00:51:14 1999
***************
*** 4,7 ****
XDEPFILES= ser-tcp.o
NAT_FILE= nm-linux.h
! NATDEPFILES= infptrace.o solib.o inftarg.o fork-child.o corelow.o core-aout.o core-regset.o i386v-nat.o i386v4-nat.o
--- 4,7 ----
XDEPFILES= ser-tcp.o
NAT_FILE= nm-linux.h
! NATDEPFILES= infptrace.o solib.o inftarg.o fork-child.o corelow.o core-aout.o core-regset.o i386v-nat.o i386v4-nat.o linuxthreads.o
diff -Ncr /home/kingdon/work/gdb/gdb/config/i386/nm-linux.h ./gdb/config/i386/nm-linux.h
*** /home/kingdon/work/gdb/gdb/config/i386/nm-linux.h Thu Jul 8 16:09:02 1999
--- ./gdb/config/i386/nm-linux.h Fri Aug 13 00:49:54 1999
***************
*** 71,74 ****
--- 71,92 ----
extern int
i386_remove_watchpoint PARAMS ((int pid, CORE_ADDR addr, int len));
+ /* Support for the glibc linuxthreads package. */
+
+ #ifdef __STDC__
+ struct objfile;
+ #endif
+
+ extern void
+ linuxthreads_new_objfile PARAMS ((struct objfile *objfile));
+ #define target_new_objfile(OBJFILE) linuxthreads_new_objfile (OBJFILE)
+
+ extern char *
+ linuxthreads_pid_to_str PARAMS ((int pid));
+ #define target_pid_to_str(PID) linuxthreads_pid_to_str (PID)
+
+ extern int
+ linuxthreads_prepare_to_proceed PARAMS ((int step));
+ #define PREPARE_TO_PROCEED() linuxthreads_prepare_to_proceed (1)
+
#endif /* #ifndef NM_LINUX_H */
diff -Ncr /home/kingdon/work/gdb/gdb/config/i386/tm-linux.h ./gdb/config/i386/tm-linux.h
*** /home/kingdon/work/gdb/gdb/config/i386/tm-linux.h Tue Aug 3 16:40:28 1999
--- ./gdb/config/i386/tm-linux.h Sat Aug 14 19:15:35 1999
***************
*** 104,107 ****
--- 104,121 ----
extern CORE_ADDR i386_linux_sigtramp_saved_sp PARAMS ((struct frame_info *));
+
+ /* Some versions of Linux have real-time signal support in the C library, and
+ some don't. We have to include this file to find out. */
+ #include <signal.h>
+
+ #ifdef __SIGRTMIN
+ #define REALTIME_LO __SIGRTMIN
+ #define REALTIME_HI (__SIGRTMAX + 1)
+ #else
+ #define REALTIME_LO 32
+ #define REALTIME_HI 64
+ #endif
+
+
#endif /* #ifndef TM_LINUX_H */
diff -Ncr /home/kingdon/work/gdb/gdb/inferior.h ./gdb/inferior.h
*** /home/kingdon/work/gdb/gdb/inferior.h Thu Jul 8 16:02:22 1999
--- ./gdb/inferior.h Fri Aug 13 00:43:51 1999
***************
*** 260,265 ****
--- 260,271 ----
extern int signal_pass_state PARAMS ((int));
+ extern int signal_stop_update PARAMS ((int, int));
+
+ extern int signal_print_update PARAMS ((int, int));
+
+ extern int signal_pass_update PARAMS ((int, int));
+
/* From infcmd.c */
extern void tty_command PARAMS ((char *, int));
diff -Ncr /home/kingdon/work/gdb/gdb/infrun.c ./gdb/infrun.c
*** /home/kingdon/work/gdb/gdb/infrun.c Thu Aug 12 11:13:29 1999
--- ./gdb/infrun.c Fri Aug 13 00:33:34 1999
***************
*** 3291,3296 ****
--- 3291,3323 ----
return signal_program[signo];
}
+ int signal_stop_update (signo, state)
+ int signo;
+ int state;
+ {
+ int ret = signal_stop[signo];
+ signal_stop[signo] = state;
+ return ret;
+ }
+
+ int signal_print_update (signo, state)
+ int signo;
+ int state;
+ {
+ int ret = signal_print[signo];
+ signal_print[signo] = state;
+ return ret;
+ }
+
+ int signal_pass_update (signo, state)
+ int signo;
+ int state;
+ {
+ int ret = signal_program[signo];
+ signal_program[signo] = state;
+ return ret;
+ }
+
static void
sig_print_header (void)
{
diff -Ncr /home/kingdon/work/gdb/gdb/linuxthreads.c ./gdb/linuxthreads.c
*** /home/kingdon/work/gdb/gdb/linuxthreads.c Wed Dec 31 19:00:00 1969
--- ./gdb/linuxthreads.c Fri Aug 13 00:46:01 1999
***************
*** 0 ****
--- 1,1631 ----
+ /* Low level interface for debugging GNU/Linux threads for GDB,
+ the GNU debugger.
+ Copyright 1998, 1999 Free Software Foundation, Inc.
+
+ This file is part of GDB.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
+
+ /* This module implements the debugging interface of the linuxthreads package
+ of the glibc. This package implements a simple clone()-based implementation
+ of Posix threads for Linux. To use this module, be sure that you have at
+ least the version of the linuxthreads package that holds the support of
+ GDB (currently 0.8 included in the glibc-2.0.7).
+
+ Right now, the linuxthreads package does not care of priority scheduling,
+ so, neither this module does; In particular, the threads are resumed
+ in any order, which could lead to different scheduling than the one
+ happening when GDB does not control the execution.
+
+ The latest point is that ptrace(PT_ATTACH, ...) is intrusive in Linux:
+ When a process is attached, then the attaching process becomes the current
+ parent of the attached process, and the old parent has lost this child.
+ If the old parent does a wait[...](), then this child is no longer
+ considered by the kernel as a child of the old parent, thus leading to
+ results of the call different when the child is attached and when it's not.
+
+ A fix has been submitted to the Linux community to solve this problem,
+ which consequences are not visible to the application itself, but on the
+ process which may wait() for the completion of the application (mostly,
+ it may consider that the application no longer exists (errno == ECHILD),
+ although it does, and thus being unable to get the exit status and resource
+ usage of the child. If by chance, it is able to wait() for the application
+ after it has died (by receiving first a SIGCHILD, and then doing a wait(),
+ then the exit status and resource usage may be wrong, because the
+ linuxthreads package heavily relies on wait() synchronization to keep
+ them correct. */
+
+ #include <sys/types.h> /* for pid_t */
+ #include <sys/ptrace.h> /* for PT_* flags */
+ #include <sys/wait.h> /* for WUNTRACED and __WCLONE flags */
+ #include <signal.h> /* for struct sigaction and NSIG */
+ #include <sys/utsname.h>
+
+ #include "defs.h"
+ #include "target.h"
+ #include "inferior.h"
+ #include "gdbcore.h"
+ #include "gdbthread.h"
+ #include "wait.h"
+ #include "gdbcmd.h"
+ #include "breakpoint.h"
+
+ #ifndef PT_ATTACH
+ #define PT_ATTACH PTRACE_ATTACH
+ #endif
+ #ifndef PT_KILL
+ #define PT_KILL PTRACE_KILL
+ #endif
+ #ifndef PT_READ_U
+ #define PT_READ_U PTRACE_PEEKUSR
+ #endif
+
+ #ifdef NSIG
+ #define LINUXTHREAD_NSIG NSIG
+ #else
+ #ifdef _NSIG
+ #define LINUXTHREAD_NSIG _NSIG
+ #endif
+ #endif
+
+ extern int child_suppress_run; /* make inftarg.c non-runnable */
+ struct target_ops linuxthreads_ops; /* Forward declaration */
+ extern struct target_ops child_ops; /* target vector for inftarg.c */
+
+ static CORE_ADDR linuxthreads_handles; /* array of linuxthreads handles */
+ static CORE_ADDR linuxthreads_manager; /* pid of linuxthreads manager thread */
+ static CORE_ADDR linuxthreads_initial; /* pid of linuxthreads initial thread */
+ static CORE_ADDR linuxthreads_debug; /* linuxthreads internal debug flag */
+ static CORE_ADDR linuxthreads_num; /* number of valid handle entries */
+
+ static int linuxthreads_max; /* Maximum number of linuxthreads.
+ Zero if this executable doesn't use
+ threads, or wasn't linked with a
+ debugger-friendly version of the
+ linuxthreads library. */
+
+ static int linuxthreads_sizeof_handle; /* size of a linuxthreads handle */
+ static int linuxthreads_offset_descr; /* h_descr offset of the linuxthreads
+ handle */
+ static int linuxthreads_offset_pid; /* p_pid offset of the linuxthreads
+ descr */
+
+ static int linuxthreads_manager_pid; /* manager pid */
+ static int linuxthreads_initial_pid; /* initial pid */
+
+ /* These variables form a bag of threads with interesting status. If
+ wait_thread (PID) finds that PID stopped for some interesting
+ reason (i.e. anything other than stopped with SIGSTOP), then it
+ records its status in this queue. linuxthreads_wait and
+ linuxthreads_find_trap extract processes from here. */
+ static int *linuxthreads_wait_pid; /* wait array of pid */
+ static int *linuxthreads_wait_status; /* wait array of status */
+ static int linuxthreads_wait_last; /* index of last valid elt in
+ linuxthreads_wait_{pid,status} */
+
+ static sigset_t linuxthreads_wait_mask; /* sigset with SIGCHLD */
+
+ static int linuxthreads_step_pid; /* current stepped pid */
+ static int linuxthreads_step_signo; /* current stepped target signal */
+ static int linuxthreads_exit_status; /* exit status of initial thread */
+
+ static int linuxthreads_inferior_pid; /* temporary internal inferior pid */
+ static int linuxthreads_breakpoint_pid; /* last pid that hit a breakpoint */
+ static int linuxthreads_attach_pending; /* attach command without wait */
+
+ static int linuxthreads_breakpoints_inserted; /* any breakpoints inserted */
+
+ /* LinuxThreads uses certain signals for communication between
+ processes; we need to tell GDB to pass them through silently to the
+ inferior. The LinuxThreads library has global variables we can
+ read containing the relevant signal numbers, but since the signal
+ numbers are chosen at run-time, those variables aren't initialized
+ until the shared library's constructors have had a chance to run. */
+
+ struct linuxthreads_signal {
+
+ /* The name of the LinuxThreads library variable that contains
+ the signal number. */
+ char *var;
+
+ /* True if this variable must exist for us to debug properly. */
+ int required;
+
+ /* The variable's address in the inferior, or zero if the
+ LinuxThreads library hasn't been loaded into this inferior yet. */
+ CORE_ADDR addr;
+
+ /* The signal number, or zero if we don't know yet (either because
+ we haven't found the variable, or it hasn't been initialized).
+ This is an actual target signal number that you could pass to
+ `kill', not a GDB signal number. */
+ int signal;
+
+ /* GDB's original settings for `stop' and `print' for this signal.
+ We restore them when the user selects a different executable.
+ Invariant: if sig->signal != 0, then sig->{stop,print} contain
+ the original settings. */
+ int stop, print;
+ };
+
+ struct linuxthreads_signal linuxthreads_sig_restart = {
+ "__pthread_sig_restart", 1, 0, 0, 0
+ };
+ struct linuxthreads_signal linuxthreads_sig_cancel = {
+ "__pthread_sig_cancel", 1, 0, 0, 0
+ };
+ struct linuxthreads_signal linuxthreads_sig_debug = {
+ "__pthread_sig_debug", 0, 0, 0, 0
+ };
+
+ /* A table of breakpoint locations, one per PID. */
+ static struct linuxthreads_breakpoint {
+ CORE_ADDR pc; /* PC of breakpoint */
+ int pid; /* pid of breakpoint */
+ int step; /* whether the pc has been reached after sstep */
+ } *linuxthreads_breakpoint_zombie; /* Zombie breakpoints array */
+ static int linuxthreads_breakpoint_last; /* Last zombie breakpoint */
+
+ /* linuxthreads_{insert,remove}_breakpoint pass the breakpoint address
+ to {insert,remove}_breakpoint via this variable, since
+ iterate_active_threads doesn't provide any way to pass values
+ through to the worker function. */
+ static CORE_ADDR linuxthreads_breakpoint_addr;
+
+ #define REMOVE_BREAKPOINT_ZOMBIE(_i) \
+ { \
+ if ((_i) < linuxthreads_breakpoint_last) \
+ linuxthreads_breakpoint_zombie[(_i)] = \
+ linuxthreads_breakpoint_zombie[linuxthreads_breakpoint_last]; \
+ linuxthreads_breakpoint_last--; \
+ }
+
+
+
+ #ifndef PTRACE_XFER_TYPE
+ #define PTRACE_XFER_TYPE int
+ #endif
+ /* Check to see if the given thread is alive. */
+ static int
+ linuxthreads_thread_alive (pid)
+ int pid;
+ {
+ errno = 0;
+ return ptrace (PT_READ_U, pid, (PTRACE_ARG3_TYPE)0, 0) >= 0 || errno == 0;
+ }
+
+ /* On detach(), find a SIGTRAP status. If stop is non-zero, find a
+ SIGSTOP one, too.
+
+ Make sure PID is ready to run, and free of interference from our
+ efforts to debug it (e.g., pending SIGSTOP or SIGTRAP signals). If
+ STOP is zero, just look for a SIGTRAP. If STOP is non-zero, look
+ for a SIGSTOP, too. Return non-zero if PID is alive and ready to
+ run; return zero if PID is dead.
+
+ PID may or may not be stopped at the moment, and we may or may not
+ have waited for it already. We check the linuxthreads_wait bag in
+ case we've already got a status for it. We may possibly wait for
+ it ourselves.
+
+ PID may have signals waiting to be delivered. If they're caused by
+ our efforts to debug it, accept them with wait, but don't pass them
+ through to PID. Do pass all other signals through. */
+ static int
+ linuxthreads_find_trap (pid, stop)
+ int pid;
+ int stop;
+ {
+ int i;
+ int rpid;
+ int status;
+ int found_stop = 0;
+ int found_trap = 0;
+
+ /* PID may have any number of signals pending. The kernel will
+ report each of them to us via wait, and then it's up to us to
+ pass them along to the process via ptrace, if we so choose.
+
+ We need to paw through the whole set until we've found a SIGTRAP
+ (or a SIGSTOP, if `stop' is set). We don't pass the SIGTRAP (or
+ SIGSTOP) through, but we do re-send all the others, so PID will
+ receive them when we resume it. */
+ int *wstatus = alloca (LINUXTHREAD_NSIG * sizeof (int));
+ int last = 0;
+
+ /* Look at the pending status */
+ for (i = linuxthreads_wait_last; i >= 0; i--)
+ if (linuxthreads_wait_pid[i] == pid)
+ {
+ status = linuxthreads_wait_status[i];
+
+ /* Delete the i'th member of the table. Since the table is
+ unordered, we can do this simply by copying the table's
+ last element to the i'th position, and shrinking the table
+ by one element. */
+ if (i < linuxthreads_wait_last)
+ {
+ linuxthreads_wait_status[i] =
+ linuxthreads_wait_status[linuxthreads_wait_last];
+ linuxthreads_wait_pid[i] =
+ linuxthreads_wait_pid[linuxthreads_wait_last];
+ }
+ linuxthreads_wait_last--;
+
+ if (!WIFSTOPPED(status)) /* Thread has died */
+ return 0;
+
+ if (WSTOPSIG(status) == SIGTRAP)
+ {
+ if (stop)
+ found_trap = 1;
+ else
+ return 1;
+ }
+ else if (WSTOPSIG(status) == SIGSTOP)
+ {
+ if (stop)
+ found_stop = 1;
+ }
+ else
+ {
+ wstatus[0] = status;
+ last = 1;
+ }
+
+ break;
+ }
+
+ if (stop)
+ {
+ /* Make sure that we'll find what we're looking for. */
+ if (!found_trap)
+ kill (pid, SIGTRAP);
+ if (!found_stop)
+ kill (pid, SIGSTOP);
+ }
+
+ /* Catch all status until SIGTRAP and optionally SIGSTOP show up. */
+ for (;;)
+ {
+ child_resume (pid, 1, TARGET_SIGNAL_0);
+
+ for (;;)
+ {
+ rpid = waitpid (pid, &status, __WCLONE);
+ if (rpid > 0)
+ break;
+ if (errno == EINTR)
+ continue;
+
+ /* There are a few reasons the wait call above may have
+ failed. If the thread manager dies, its children get
+ reparented, and this interferes with GDB waiting for
+ them, in some cases. Another possibility is that the
+ initial thread was not cloned, so calling wait with
+ __WCLONE won't find it. I think neither of these should
+ occur in modern Linux kernels --- they don't seem to in
+ 2.0.36. */
+ rpid = waitpid (pid, &status, 0);
+ if (rpid > 0)
+ break;
+ if (errno != EINTR)
+ perror_with_name ("waitpid");
+ }
+
+ if (!WIFSTOPPED(status)) /* Thread has died */
+ return 0;
+
+ if (WSTOPSIG(status) == SIGTRAP)
+ if (!stop || found_stop)
+ break;
+ else
+ found_trap = 1;
+ else if (WSTOPSIG(status) != SIGSTOP)
+ wstatus[last++] = status;
+ else if (stop)
+ if (found_trap)
+ break;
+ else
+ found_stop = 1;
+ }
+
+ /* Resend any other signals we noticed to the thread, to be received
+ when we continue it. */
+ while (--last >= 0)
+ kill (pid, WSTOPSIG(wstatus[last]));
+
+ return 1;
+ }
+
+ /* Cleanup stub for save_inferior_pid. */
+ static void
+ restore_inferior_pid (arg)
+ void *arg;
+ {
+ int pid = (int) arg;
+ inferior_pid = pid;
+ }
+
+ /* Register a cleanup to restore the value of inferior_pid. */
+ static struct cleanup *
+ save_inferior_pid ()
+ {
+ return make_cleanup (restore_inferior_pid, (void *) inferior_pid);
+ }
+
+ static void
+ sigchld_handler(signo)
+ int signo;
+ {
+ /* This handler is used to get an EINTR while doing waitpid()
+ when an event is received */
+ }
+
+ /* Have we already collected a wait status for PID in the
+ linuxthreads_wait bag? */
+ static int
+ linuxthreads_pending_status (pid)
+ int pid;
+ {
+ int i;
+ for (i = linuxthreads_wait_last; i >= 0; i--)
+ if (linuxthreads_wait_pid[i] == pid)
+ return 1;
+ return 0;
+ }
+
+
+ /* Internal linuxthreads signal management */
+
+ /* Check in OBJFILE for the variable that holds the number for signal SIG.
+ We assume that we've already found other LinuxThreads-ish variables
+ in OBJFILE, so we complain if it's required, but not there.
+ Return true iff things are okay. */
+ static int
+ find_signal_var (struct linuxthreads_signal *sig,
+ struct objfile *objfile)
+ {
+ struct minimal_symbol *ms = lookup_minimal_symbol (sig->var, NULL, objfile);
+
+ if (! ms)
+ {
+ if (sig->required)
+ {
+ fprintf_unfiltered (gdb_stderr,
+ "Unable to find linuxthreads symbol \"%s\"\n",
+ sig->var);
+ return 0;
+ }
+ else
+ {
+ sig->addr = 0;
+ return 1;
+ }
+ }
+
+ sig->addr = SYMBOL_VALUE_ADDRESS (ms);
+
+ return 1;
+ }
+
+ static int
+ find_all_signal_vars (struct objfile *objfile)
+ {
+ return ( find_signal_var (&linuxthreads_sig_restart, objfile)
+ && find_signal_var (&linuxthreads_sig_cancel, objfile)
+ && find_signal_var (&linuxthreads_sig_debug, objfile));
+ }
+
+ /* A struct complaint isn't appropriate here. */
+ static int complained_cannot_determine_thread_signal_number = 0;
+
+ /* Check to see if the variable holding the signal number for SIG has
+ been initialized yet. If it has, tell GDB to pass that signal
+ through to the inferior silently. */
+ static void
+ check_signal_number (struct linuxthreads_signal *sig)
+ {
+ int num;
+
+ if (sig->signal)
+ /* We already know this signal number. */
+ return;
+
+ if (! sig->addr)
+ /* We don't know the variable's address yet. */
+ return;
+
+ if (target_read_memory (sig->addr, (char *)&num, sizeof (num))
+ != 0)
+ {
+ /* If this happens once, it'll probably happen for all the
+ signals, so only complain once. */
+ if (! complained_cannot_determine_thread_signal_number)
+ warning ("Cannot determine thread signal number; "
+ "GDB may report spurious signals.");
+ complained_cannot_determine_thread_signal_number = 1;
+ return;
+ }
+
+ if (num == 0)
+ /* It hasn't been initialized yet. */
+ return;
+
+ /* We know sig->signal was zero, and is becoming non-zero, so it's
+ okay to sample GDB's original settings. */
+ sig->signal = num;
+ sig->stop = signal_stop_update (target_signal_from_host (num), 0);
+ sig->print = signal_print_update (target_signal_from_host (num), 0);
+ }
+
+
+ static void
+ check_all_signal_numbers (void)
+ {
+ /* If this isn't a LinuxThreads program, quit early. */
+ if (! linuxthreads_max)
+ return;
+
+ check_signal_number (&linuxthreads_sig_restart);
+ check_signal_number (&linuxthreads_sig_cancel);
+ check_signal_number (&linuxthreads_sig_debug);
+
+ /* handle linuxthread exit */
+ if (linuxthreads_sig_debug.signal
+ || linuxthreads_sig_restart.signal)
+ {
+ struct sigaction sact;
+
+ sact.sa_handler = sigchld_handler;
+ sigemptyset(&sact.sa_mask);
+ sact.sa_flags = 0;
+ if (linuxthreads_sig_debug.signal > 0)
+ sigaction(linuxthreads_sig_cancel.signal, &sact, NULL);
+ else
+ sigaction(linuxthreads_sig_restart.signal, &sact, NULL);
+ }
+ }
+
+
+ /* Restore GDB's original settings for SIG.
+ This should only be called when we're no longer sure if we're
+ talking to an executable that uses LinuxThreads, so we clear the
+ signal number and variable address too. */
+ static void
+ restore_signal (struct linuxthreads_signal *sig)
+ {
+ if (! sig->signal)
+ return;
+
+ /* We know sig->signal was non-zero, and is becoming zero, so it's
+ okay to restore GDB's original settings. */
+ signal_stop_update (target_signal_from_host (sig->signal), sig->stop);
+ signal_print_update (target_signal_from_host (sig->signal), sig->print);
+
+ sig->signal = 0;
+ sig->addr = 0;
+ }
+
+
+ /* Restore GDB's original settings for all LinuxThreads signals.
+ This should only be called when we're no longer sure if we're
+ talking to an executable that uses LinuxThreads, so we clear the
+ signal number and variable address too. */
+ static void
+ restore_all_signals (void)
+ {
+ restore_signal (&linuxthreads_sig_restart);
+ restore_signal (&linuxthreads_sig_cancel);
+ restore_signal (&linuxthreads_sig_debug);
+
+ /* If it happens again, we should complain again. */
+ complained_cannot_determine_thread_signal_number = 0;
+ }
+
+
+
+
+ /* Apply FUNC to the pid of each active thread. This consults the
+ inferior's handle table to find active threads.
+
+ If ALL is non-zero, process all threads.
+ If ALL is zero, skip threads with pending status. */
+ static void
+ iterate_active_threads (func, all)
+ void (*func)(int);
+ int all;
+ {
+ CORE_ADDR descr;
+ int pid;
+ int i;
+ int num;
+
+ read_memory (linuxthreads_num, (char *)&num, sizeof (int));
+
+ for (i = 0; i < linuxthreads_max && num > 0; i++)
+ {
+ read_memory (linuxthreads_handles +
+ linuxthreads_sizeof_handle * i + linuxthreads_offset_descr,
+ (char *)&descr, sizeof (void *));
+ if (descr)
+ {
+ num--;
+ read_memory (descr + linuxthreads_offset_pid,
+ (char *)&pid, sizeof (pid_t));
+ if (pid > 0 && pid != linuxthreads_manager_pid
+ && (all || (!linuxthreads_pending_status (pid))))
+ (*func)(pid);
+ }
+ }
+
+ }
+
+ /* Insert a thread breakpoint at linuxthreads_breakpoint_addr.
+ This is the worker function for linuxthreads_insert_breakpoint,
+ which passes it to iterate_active_threads. */
+ static void
+ insert_breakpoint (pid)
+ int pid;
+ {
+ int j;
+
+ /* Remove (if any) the positive zombie breakpoint. */
+ for (j = linuxthreads_breakpoint_last; j >= 0; j--)
+ if (linuxthreads_breakpoint_zombie[j].pid == pid)
+ {
+ if ((linuxthreads_breakpoint_zombie[j].pc - DECR_PC_AFTER_BREAK
+ == linuxthreads_breakpoint_addr)
+ && !linuxthreads_breakpoint_zombie[j].step)
+ REMOVE_BREAKPOINT_ZOMBIE(j);
+ break;
+ }
+ }
+
+ /* Note that we're about to remove a thread breakpoint at
+ linuxthreads_breakpoint_addr.
+
+ This is the worker function for linuxthreads_remove_breakpoint,
+ which passes it to iterate_active_threads. The actual work of
+ overwriting the breakpoint instruction is done by
+ child_ops.to_remove_breakpoint; here, we simply create a zombie
+ breakpoint if the thread's PC is pointing at the breakpoint being
+ removed. */
+ static void
+ remove_breakpoint (pid)
+ int pid;
+ {
+ int j;
+
+ /* Insert a positive zombie breakpoint (if needed). */
+ for (j = 0; j <= linuxthreads_breakpoint_last; j++)
+ if (linuxthreads_breakpoint_zombie[j].pid == pid)
+ break;
+
+ if (in_thread_list (pid) && linuxthreads_thread_alive (pid))
+ {
+ CORE_ADDR pc = read_pc_pid (pid);
+ if (linuxthreads_breakpoint_addr == pc - DECR_PC_AFTER_BREAK
+ && j > linuxthreads_breakpoint_last)
+ {
+ linuxthreads_breakpoint_zombie[j].pid = pid;
+ linuxthreads_breakpoint_zombie[j].pc = pc;
+ linuxthreads_breakpoint_zombie[j].step = 0;
+ linuxthreads_breakpoint_last++;
+ }
+ }
+ }
+
+ /* Kill a thread */
+ static void
+ kill_thread (pid)
+ int pid;
+ {
+ if (in_thread_list (pid))
+ ptrace (PT_KILL, pid, (PTRACE_ARG3_TYPE) 0, 0);
+ else
+ kill (pid, SIGKILL);
+ }
+
+ /* Resume a thread */
+ static void
+ resume_thread (pid)
+ int pid;
+ {
+ if (pid != inferior_pid
+ && in_thread_list (pid)
+ && linuxthreads_thread_alive (pid))
+ if (pid == linuxthreads_step_pid)
+ child_resume (pid, 1, linuxthreads_step_signo);
+ else
+ child_resume (pid, 0, TARGET_SIGNAL_0);
+ }
+
+ /* Detach a thread */
+ static void
+ detach_thread (pid)
+ int pid;
+ {
+ if (in_thread_list (pid) && linuxthreads_thread_alive (pid))
+ {
+ /* Remove pending SIGTRAP and SIGSTOP */
+ linuxthreads_find_trap (pid, 1);
+
+ inferior_pid = pid;
+ detach (TARGET_SIGNAL_0);
+ inferior_pid = linuxthreads_manager_pid;
+ }
+ }
+
+ /* Stop a thread */
+ static void
+ stop_thread (pid)
+ int pid;
+ {
+ if (pid != inferior_pid)
+ if (in_thread_list (pid))
+ kill (pid, SIGSTOP);
+ else if (ptrace (PT_ATTACH, pid, (PTRACE_ARG3_TYPE) 0, 0) == 0)
+ {
+ if (!linuxthreads_attach_pending)
+ printf_unfiltered ("[New %s]\n", target_pid_to_str (pid));
+ add_thread (pid);
+ if (linuxthreads_sig_debug.signal)
+ /* After a new thread in glibc 2.1 signals gdb its existence,
+ it suspends itself and wait for linuxthreads_sig_restart,
+ now we can wake up it. */
+ kill (pid, linuxthreads_sig_restart.signal);
+ }
+ else
+ perror_with_name ("ptrace in stop_thread");
+ }
+
+ /* Wait for a thread */
+ static void
+ wait_thread (pid)
+ int pid;
+ {
+ int status;
+ int rpid;
+
+ if (pid != inferior_pid && in_thread_list (pid))
+ {
+ for (;;)
+ {
+ /* Get first pid status. */
+ rpid = waitpid(pid, &status, __WCLONE);
+ if (rpid > 0)
+ break;
+ if (errno == EINTR)
+ continue;
+
+ /* There are two reasons this might have failed:
+
+ 1) PID is the initial thread, which wasn't cloned, so
+ passing the __WCLONE flag to waitpid prevented us from
+ finding it.
+
+ 2) The manager thread is the parent of all but the
+ initial thread; if it dies, the children will all be
+ reparented to init, which will wait for them. This means
+ our call to waitpid won't find them.
+
+ Actually, based on a casual look at the 2.0.36 kernel
+ code, I don't think either of these cases happen. But I
+ don't have things set up for remotely debugging the
+ kernel, so I'm not sure. And perhaps older kernels
+ didn't work. */
+ rpid = waitpid(pid, &status, 0);
+ if (rpid > 0)
+ break;
+ if (errno != EINTR && linuxthreads_thread_alive (pid))
+ perror_with_name ("waitpid");
+
+ /* the thread is dead. */
+ return;
+ }
+ if (!WIFSTOPPED(status) || WSTOPSIG(status) != SIGSTOP)
+ {
+ linuxthreads_wait_pid[++linuxthreads_wait_last] = pid;
+ linuxthreads_wait_status[linuxthreads_wait_last] = status;
+ }
+ }
+ }
+
+ /* Walk through the linuxthreads handles in order to detect all
+ threads and stop them */
+ static void
+ update_stop_threads (test_pid)
+ int test_pid;
+ {
+ struct cleanup *old_chain = NULL;
+
+ check_all_signal_numbers ();
+
+ if (linuxthreads_manager_pid == 0)
+ {
+ if (linuxthreads_manager)
+ {
+ if (test_pid > 0 && test_pid != inferior_pid)
+ {
+ old_chain = save_inferior_pid ();
+ inferior_pid = test_pid;
+ }
+ read_memory (linuxthreads_manager,
+ (char *)&linuxthreads_manager_pid, sizeof (pid_t));
+ }
+ if (linuxthreads_initial)
+ {
+ if (test_pid > 0 && test_pid != inferior_pid)
+ {
+ old_chain = save_inferior_pid ();
+ inferior_pid = test_pid;
+ }
+ read_memory(linuxthreads_initial,
+ (char *)&linuxthreads_initial_pid, sizeof (pid_t));
+ }
+ }
+
+ if (linuxthreads_manager_pid != 0)
+ {
+ if (old_chain == NULL && test_pid > 0 &&
+ test_pid != inferior_pid && linuxthreads_thread_alive (test_pid))
+ {
+ old_chain = save_inferior_pid ();
+ inferior_pid = test_pid;
+ }
+
+ if (linuxthreads_thread_alive (inferior_pid))
+ {
+ if (test_pid > 0)
+ {
+ if (test_pid != linuxthreads_manager_pid
+ && !linuxthreads_pending_status (linuxthreads_manager_pid))
+ {
+ stop_thread (linuxthreads_manager_pid);
+ wait_thread (linuxthreads_manager_pid);
+ }
+ if (!in_thread_list (test_pid))
+ {
+ if (!linuxthreads_attach_pending)
+ printf_unfiltered ("[New %s]\n",
+ target_pid_to_str (test_pid));
+ add_thread (test_pid);
+ if (linuxthreads_sig_debug.signal
+ && inferior_pid == test_pid)
+ /* After a new thread in glibc 2.1 signals gdb its
+ existence, it suspends itself and wait for
+ linuxthreads_sig_restart, now we can wake up
+ it. */
+ kill (test_pid, linuxthreads_sig_restart.signal);
+ }
+ }
+ iterate_active_threads (stop_thread, 0);
+ iterate_active_threads (wait_thread, 0);
+ }
+ }
+
+ if (old_chain != NULL)
+ do_cleanups (old_chain);
+ }
+
+ /* This routine is called whenever a new symbol table is read in, or when all
+ symbol tables are removed. libpthread can only be initialized when it
+ finds the right variables in libpthread.so. Since it's a shared library,
+ those variables don't show up until the library gets mapped and the symbol
+ table is read in. */
+
+ void
+ linuxthreads_new_objfile (objfile)
+ struct objfile *objfile;
+ {
+ struct minimal_symbol *ms;
+
+ if (!objfile)
+ {
+ /* We're starting an entirely new executable, so we can no
+ longer be sure that it uses LinuxThreads. Restore the signal
+ flags to their original states. */
+ restore_all_signals ();
+
+ /* Indicate that we don't know anything's address any more. */
+ linuxthreads_max = 0;
+
+ return;
+ }
+
+ /* If we've already found our variables in another objfile, don't
+ bother looking for them again. */
+ if (linuxthreads_max)
+ return;
+
+ if (! lookup_minimal_symbol ("__pthread_initial_thread", NULL, objfile))
+ /* This object file isn't the pthreads library. */
+ return;
+
+ if ((ms = lookup_minimal_symbol ("__pthread_threads_debug",
+ NULL, objfile)) == NULL)
+ {
+ /* The debugging-aware libpthreads is not present in this objfile */
+ warning ("\
+ This program seems to use POSIX threads, but the thread library used\n\
+ does not support debugging. This may make using GDB difficult. Don't\n\
+ set breakpoints or single-step through code that might be executed by\n\
+ any thread other than the main thread.");
+ return;
+ }
+ linuxthreads_debug = SYMBOL_VALUE_ADDRESS (ms);
+
+ /* Read internal structures configuration */
+ if ((ms = lookup_minimal_symbol ("__pthread_sizeof_handle",
+ NULL, objfile)) == NULL
+ || target_read_memory (SYMBOL_VALUE_ADDRESS (ms),
+ (char *)&linuxthreads_sizeof_handle,
+ sizeof (linuxthreads_sizeof_handle)) != 0)
+ {
+ fprintf_unfiltered (gdb_stderr,
+ "Unable to find linuxthreads symbol \"%s\"\n",
+ "__pthread_sizeof_handle");
+ return;
+ }
+
+ if ((ms = lookup_minimal_symbol ("__pthread_offsetof_descr",
+ NULL, objfile)) == NULL
+ || target_read_memory (SYMBOL_VALUE_ADDRESS (ms),
+ (char *)&linuxthreads_offset_descr,
+ sizeof (linuxthreads_offset_descr)) != 0)
+ {
+ fprintf_unfiltered (gdb_stderr,
+ "Unable to find linuxthreads symbol \"%s\"\n",
+ "__pthread_offsetof_descr");
+ return;
+ }
+
+ if ((ms = lookup_minimal_symbol ("__pthread_offsetof_pid",
+ NULL, objfile)) == NULL
+ || target_read_memory (SYMBOL_VALUE_ADDRESS (ms),
+ (char *)&linuxthreads_offset_pid,
+ sizeof (linuxthreads_offset_pid)) != 0)
+ {
+ fprintf_unfiltered (gdb_stderr,
+ "Unable to find linuxthreads symbol \"%s\"\n",
+ "__pthread_offsetof_pid");
+ return;
+ }
+
+ if (! find_all_signal_vars (objfile))
+ return;
+
+ /* Read adresses of internal structures to access */
+ if ((ms = lookup_minimal_symbol ("__pthread_handles",
+ NULL, objfile)) == NULL)
+ {
+ fprintf_unfiltered (gdb_stderr,
+ "Unable to find linuxthreads symbol \"%s\"\n",
+ "__pthread_handles");
+ return;
+ }
+ linuxthreads_handles = SYMBOL_VALUE_ADDRESS (ms);
+
+ if ((ms = lookup_minimal_symbol ("__pthread_handles_num",
+ NULL, objfile)) == NULL)
+ {
+ fprintf_unfiltered (gdb_stderr,
+ "Unable to find linuxthreads symbol \"%s\"\n",
+ "__pthread_handles_num");
+ return;
+ }
+ linuxthreads_num = SYMBOL_VALUE_ADDRESS (ms);
+
+ if ((ms = lookup_minimal_symbol ("__pthread_manager_thread",
+ NULL, objfile)) == NULL)
+ {
+ fprintf_unfiltered (gdb_stderr,
+ "Unable to find linuxthreads symbol \"%s\"\n",
+ "__pthread_manager_thread");
+ return;
+ }
+ linuxthreads_manager = SYMBOL_VALUE_ADDRESS (ms) + linuxthreads_offset_pid;
+
+ if ((ms = lookup_minimal_symbol ("__pthread_initial_thread",
+ NULL, objfile)) == NULL)
+ {
+ fprintf_unfiltered (gdb_stderr,
+ "Unable to find linuxthreads symbol \"%s\"\n",
+ "__pthread_initial_thread");
+ return;
+ }
+ linuxthreads_initial = SYMBOL_VALUE_ADDRESS (ms) + linuxthreads_offset_pid;
+
+ /* Search for this last, so it won't be set to a non-zero value unless
+ we successfully found all the symbols above. */
+ if ((ms = lookup_minimal_symbol ("__pthread_threads_max",
+ NULL, objfile)) == NULL
+ || target_read_memory (SYMBOL_VALUE_ADDRESS (ms),
+ (char *)&linuxthreads_max,
+ sizeof (linuxthreads_max)) != 0)
+ {
+ fprintf_unfiltered (gdb_stderr,
+ "Unable to find linuxthreads symbol \"%s\"\n",
+ "__pthread_threads_max");
+ return;
+ }
+
+ /* Allocate gdb internal structures */
+ linuxthreads_wait_pid =
+ (int *)xmalloc (sizeof (int) * (linuxthreads_max + 1));
+ linuxthreads_wait_status =
+ (int *)xmalloc (sizeof (int) * (linuxthreads_max + 1));
+ linuxthreads_breakpoint_zombie = (struct linuxthreads_breakpoint *)
+ xmalloc (sizeof (struct linuxthreads_breakpoint) * (linuxthreads_max + 1));
+
+ if (inferior_pid && !linuxthreads_attach_pending)
+ {
+ int on = 1;
+ target_write_memory (linuxthreads_debug, (char *)&on, sizeof (on));
+ linuxthreads_attach_pending = 1;
+ update_stop_threads (inferior_pid);
+ linuxthreads_attach_pending = 0;
+ }
+ }
+
+ /* If we have switched threads from a one that stopped at breakpoint,
+ return 1 otherwise 0. */
+
+ int
+ linuxthreads_prepare_to_proceed (step)
+ int step;
+ {
+ if (!linuxthreads_max
+ || !linuxthreads_manager_pid
+ || !linuxthreads_breakpoint_pid
+ || !breakpoint_here_p (read_pc_pid (linuxthreads_breakpoint_pid)))
+ return 0;
+
+ if (step)
+ {
+ /* Mark the current inferior as single stepping process. */
+ linuxthreads_step_pid = inferior_pid;
+ }
+
+ linuxthreads_inferior_pid = linuxthreads_breakpoint_pid;
+ return linuxthreads_breakpoint_pid;
+ }
+
+ /* Convert a pid to printable form. */
+
+ char *
+ linuxthreads_pid_to_str (pid)
+ int pid;
+ {
+ static char buf[100];
+
+ sprintf (buf, "%s %d%s", linuxthreads_max ? "Thread" : "Pid", pid,
+ (pid == linuxthreads_manager_pid) ? " (manager thread)"
+ : (pid == linuxthreads_initial_pid) ? " (initial thread)"
+ : "");
+
+ return buf;
+ }
+
+ /* Attach to process PID, then initialize for debugging it
+ and wait for the trace-trap that results from attaching. */
+
+ static void
+ linuxthreads_attach (args, from_tty)
+ char *args;
+ int from_tty;
+ {
+ if (!args)
+ error_no_arg ("process-id to attach");
+
+ push_target (&linuxthreads_ops);
+ linuxthreads_breakpoints_inserted = 1;
+ linuxthreads_breakpoint_last = -1;
+ linuxthreads_wait_last = -1;
+ linuxthreads_exit_status = __W_STOPCODE(0);
+
+ child_ops.to_attach (args, from_tty);
+
+ if (linuxthreads_max)
+ linuxthreads_attach_pending = 1;
+ }
+
+ /* Take a program previously attached to and detaches it.
+ The program resumes execution and will no longer stop
+ on signals, etc. We'd better not have left any breakpoints
+ in the program or it'll die when it hits one. For this
+ to work, it may be necessary for the process to have been
+ previously attached. It *might* work if the program was
+ started via the normal ptrace (PTRACE_TRACEME). */
+
+ static void
+ linuxthreads_detach (args, from_tty)
+ char *args;
+ int from_tty;
+ {
+ if (linuxthreads_max)
+ {
+ int i;
+ int pid;
+ int off = 0;
+ target_write_memory (linuxthreads_debug, (char *)&off, sizeof (off));
+
+ /* Walk through linuxthreads array in order to detach known threads. */
+ if (linuxthreads_manager_pid != 0)
+ {
+ /* Get rid of all positive zombie breakpoints. */
+ for (i = 0; i <= linuxthreads_breakpoint_last; i++)
+ {
+ if (linuxthreads_breakpoint_zombie[i].step)
+ continue;
+
+ pid = linuxthreads_breakpoint_zombie[i].pid;
+ if (!linuxthreads_thread_alive (pid))
+ continue;
+
+ if (linuxthreads_breakpoint_zombie[i].pc != read_pc_pid (pid))
+ continue;
+
+ /* Continue in STEP mode until the thread pc has moved or
+ until SIGTRAP is found on the same PC. */
+ if (linuxthreads_find_trap (pid, 0)
+ && linuxthreads_breakpoint_zombie[i].pc == read_pc_pid (pid))
+ write_pc_pid (linuxthreads_breakpoint_zombie[i].pc
+ - DECR_PC_AFTER_BREAK, pid);
+ }
+
+ /* Detach thread after thread. */
+ inferior_pid = linuxthreads_manager_pid;
+ iterate_active_threads (detach_thread, 1);
+
+ /* Remove pending SIGTRAP and SIGSTOP */
+ linuxthreads_find_trap (inferior_pid, 1);
+
+ linuxthreads_wait_last = -1;
+ linuxthreads_exit_status = __W_STOPCODE(0);
+ }
+
+ linuxthreads_inferior_pid = 0;
+ linuxthreads_breakpoint_pid = 0;
+ linuxthreads_step_pid = 0;
+ linuxthreads_step_signo = TARGET_SIGNAL_0;
+ linuxthreads_manager_pid = 0;
+ linuxthreads_initial_pid = 0;
+ linuxthreads_attach_pending = 0;
+ init_thread_list (); /* Destroy thread info */
+ }
+
+ child_ops.to_detach (args, from_tty);
+
+ unpush_target (&linuxthreads_ops);
+ }
+
+ /* Resume execution of process PID. If STEP is nozero, then
+ just single step it. If SIGNAL is nonzero, restart it with that
+ signal activated. */
+
+ static void
+ linuxthreads_resume (pid, step, signo)
+ int pid;
+ int step;
+ enum target_signal signo;
+ {
+ if (!linuxthreads_max || stop_soon_quietly || linuxthreads_manager_pid == 0)
+ child_ops.to_resume (pid, step, signo);
+ else
+ {
+ int rpid;
+ if (linuxthreads_inferior_pid)
+ {
+ /* Prepare resume of the last thread that hit a breakpoint */
+ linuxthreads_breakpoints_inserted = 0;
+ rpid = linuxthreads_inferior_pid;
+ linuxthreads_step_signo = signo;
+ }
+ else
+ {
+ struct cleanup *old_chain = NULL;
+ int i;
+
+ if (pid < 0)
+ {
+ linuxthreads_step_pid = step ? inferior_pid : 0;
+ linuxthreads_step_signo = signo;
+ rpid = inferior_pid;
+ }
+ else
+ rpid = pid;
+
+ if (pid < 0 || !step)
+ {
+ linuxthreads_breakpoints_inserted = 1;
+
+ /* Walk through linuxthreads array in order to resume threads */
+ if (pid >= 0 && inferior_pid != pid)
+ {
+ old_chain = save_inferior_pid ();
+ inferior_pid = pid;
+ }
+
+ iterate_active_threads (resume_thread, 0);
+ if (linuxthreads_manager_pid != inferior_pid
+ && !linuxthreads_pending_status (linuxthreads_manager_pid))
+ resume_thread (linuxthreads_manager_pid);
+ }
+ else
+ linuxthreads_breakpoints_inserted = 0;
+
+ /* Deal with zombie breakpoint */
+ for (i = 0; i <= linuxthreads_breakpoint_last; i++)
+ if (linuxthreads_breakpoint_zombie[i].pid == rpid)
+ {
+ if (linuxthreads_breakpoint_zombie[i].pc != read_pc_pid (rpid))
+ {
+ /* The current pc is out of zombie breakpoint. */
+ REMOVE_BREAKPOINT_ZOMBIE(i);
+ }
+ break;
+ }
+
+ if (old_chain != NULL)
+ do_cleanups (old_chain);
+ }
+
+ /* Resume initial thread. */
+ if (!linuxthreads_pending_status (rpid))
+ child_ops.to_resume (rpid, step, signo);
+ }
+ }
+
+ /* Wait for any threads to stop. We may have to convert PID from a thread id
+ to a LWP id, and vice versa on the way out. */
+
+ static int
+ linuxthreads_wait (int pid, struct target_waitstatus *ourstatus)
+ {
+ int status;
+ int rpid;
+ int i;
+ int last;
+ int *wstatus;
+
+ if (linuxthreads_max && !linuxthreads_breakpoints_inserted)
+ wstatus = alloca (LINUXTHREAD_NSIG * sizeof (int));
+
+ /* See if the inferior has chosen values for its signals yet. By
+ checking for them here, we can be sure we've updated GDB's signal
+ handling table before the inferior ever gets one of them. (Well,
+ before we notice, anyway.) */
+ check_all_signal_numbers ();
+
+ for (;;)
+ {
+ if (!linuxthreads_max)
+ rpid = 0;
+ else if (!linuxthreads_breakpoints_inserted)
+ {
+ if (linuxthreads_inferior_pid)
+ pid = linuxthreads_inferior_pid;
+ else if (pid < 0)
+ pid = inferior_pid;
+ last = rpid = 0;
+ }
+ else if (pid < 0 && linuxthreads_wait_last >= 0)
+ {
+ status = linuxthreads_wait_status[linuxthreads_wait_last];
+ rpid = linuxthreads_wait_pid[linuxthreads_wait_last--];
+ }
+ else if (pid > 0 && linuxthreads_pending_status (pid))
+ {
+ for (i = linuxthreads_wait_last; i >= 0; i--)
+ if (linuxthreads_wait_pid[i] == pid)
+ break;
+ if (i < 0)
+ rpid = 0;
+ else
+ {
+ status = linuxthreads_wait_status[i];
+ rpid = pid;
+ if (i < linuxthreads_wait_last)
+ {
+ linuxthreads_wait_status[i] =
+ linuxthreads_wait_status[linuxthreads_wait_last];
+ linuxthreads_wait_pid[i] =
+ linuxthreads_wait_pid[linuxthreads_wait_last];
+ }
+ linuxthreads_wait_last--;
+ }
+ }
+ else
+ rpid = 0;
+
+ if (rpid == 0)
+ {
+ int save_errno;
+ sigset_t omask;
+
+ set_sigint_trap(); /* Causes SIGINT to be passed on to the
+ attached process. */
+ set_sigio_trap ();
+
+ sigprocmask(SIG_BLOCK, &linuxthreads_wait_mask, &omask);
+ for (;;)
+ {
+ rpid = waitpid (pid, &status, __WCLONE | WNOHANG);
+ if (rpid > 0)
+ break;
+ if (rpid == 0)
+ save_errno = 0;
+ else if (errno != EINTR)
+ save_errno = errno;
+ else
+ continue;
+
+ rpid = waitpid (pid, &status, WNOHANG);
+ if (rpid > 0)
+ break;
+ if (rpid < 0)
+ if (errno == EINTR)
+ continue;
+ else if (save_errno != 0)
+ break;
+
+ sigsuspend(&omask);
+ }
+ sigprocmask(SIG_SETMASK, &omask, NULL);
+
+ save_errno = errno;
+ clear_sigio_trap ();
+
+ clear_sigint_trap();
+
+ if (rpid == -1)
+ {
+ if (WIFEXITED(linuxthreads_exit_status))
+ {
+ store_waitstatus (ourstatus, linuxthreads_exit_status);
+ return inferior_pid;
+ }
+ else
+ {
+ fprintf_unfiltered
+ (gdb_stderr, "Child process unexpectedly missing: %s.\n",
+ safe_strerror (save_errno));
+ /* Claim it exited with unknown signal. */
+ ourstatus->kind = TARGET_WAITKIND_SIGNALLED;
+ ourstatus->value.sig = TARGET_SIGNAL_UNKNOWN;
+ return -1;
+ }
+ }
+
+ /* Signals arrive in any order. So get all signals until SIGTRAP
+ and resend previous ones to be held after. */
+ if (linuxthreads_max
+ && !linuxthreads_breakpoints_inserted
+ && WIFSTOPPED(status))
+ if (WSTOPSIG(status) == SIGTRAP)
+ {
+ while (--last >= 0)
+ kill (rpid, WSTOPSIG(wstatus[last]));
+
+ /* insert negative zombie breakpoint */
+ for (i = 0; i <= linuxthreads_breakpoint_last; i++)
+ if (linuxthreads_breakpoint_zombie[i].pid == rpid)
+ break;
+ if (i > linuxthreads_breakpoint_last)
+ {
+ linuxthreads_breakpoint_zombie[i].pid = rpid;
+ linuxthreads_breakpoint_last++;
+ }
+ linuxthreads_breakpoint_zombie[i].pc = read_pc_pid (rpid);
+ linuxthreads_breakpoint_zombie[i].step = 1;
+ }
+ else
+ {
+ if (WSTOPSIG(status) != SIGSTOP)
+ {
+ for (i = 0; i < last; i++)
+ if (wstatus[i] == status)
+ break;
+ if (i >= last)
+ wstatus[last++] = status;
+ }
+ child_resume (rpid, 1, TARGET_SIGNAL_0);
+ continue;
+ }
+ if (linuxthreads_inferior_pid)
+ linuxthreads_inferior_pid = 0;
+ }
+
+ if (linuxthreads_max && !stop_soon_quietly)
+ {
+ if (linuxthreads_max
+ && WIFSTOPPED(status)
+ && WSTOPSIG(status) == SIGSTOP)
+ {
+ /* Skip SIGSTOP signals. */
+ if (!linuxthreads_pending_status (rpid))
+ if (linuxthreads_step_pid == rpid)
+ child_resume (rpid, 1, linuxthreads_step_signo);
+ else
+ child_resume (rpid, 0, TARGET_SIGNAL_0);
+ continue;
+ }
+
+ /* Do no report exit status of cloned threads. */
+ if (WIFEXITED(status))
+ {
+ if (rpid == linuxthreads_initial_pid)
+ linuxthreads_exit_status = status;
+
+ /* Remove any zombie breakpoint. */
+ for (i = 0; i <= linuxthreads_breakpoint_last; i++)
+ if (linuxthreads_breakpoint_zombie[i].pid == rpid)
+ {
+ REMOVE_BREAKPOINT_ZOMBIE(i);
+ break;
+ }
+ if (pid > 0)
+ pid = -1;
+ continue;
+ }
+
+ /* Deal with zombie breakpoint */
+ for (i = 0; i <= linuxthreads_breakpoint_last; i++)
+ if (linuxthreads_breakpoint_zombie[i].pid == rpid)
+ break;
+
+ if (i <= linuxthreads_breakpoint_last)
+ {
+ /* There is a potential zombie breakpoint */
+ if (WIFEXITED(status)
+ || linuxthreads_breakpoint_zombie[i].pc != read_pc_pid (rpid))
+ {
+ /* The current pc is out of zombie breakpoint. */
+ REMOVE_BREAKPOINT_ZOMBIE(i);
+ }
+ else if (!linuxthreads_breakpoint_zombie[i].step
+ && WIFSTOPPED(status) && WSTOPSIG(status) == SIGTRAP)
+ {
+ /* This is a real one ==> decrement PC and restart. */
+ write_pc_pid (linuxthreads_breakpoint_zombie[i].pc
+ - DECR_PC_AFTER_BREAK, rpid);
+ if (linuxthreads_step_pid == rpid)
+ child_resume (rpid, 1, linuxthreads_step_signo);
+ else
+ child_resume (rpid, 0, TARGET_SIGNAL_0);
+ continue;
+ }
+ }
+
+ /* Walk through linuxthreads array in order to stop them */
+ if (linuxthreads_breakpoints_inserted)
+ update_stop_threads (rpid);
+
+ }
+ else if (rpid != inferior_pid)
+ continue;
+
+ store_waitstatus (ourstatus, status);
+
+ if (linuxthreads_attach_pending && !stop_soon_quietly)
+ {
+ int on = 1;
+ target_write_memory (linuxthreads_debug, (char *)&on, sizeof (on));
+ update_stop_threads (rpid);
+ linuxthreads_attach_pending = 0;
+ }
+
+ if (linuxthreads_breakpoints_inserted
+ && WIFSTOPPED(status)
+ && WSTOPSIG(status) == SIGTRAP)
+ linuxthreads_breakpoint_pid = rpid;
+ else if (linuxthreads_breakpoint_pid)
+ linuxthreads_breakpoint_pid = 0;
+
+ return rpid;
+ }
+ }
+
+ /* Fork an inferior process, and start debugging it with ptrace. */
+
+ static void
+ linuxthreads_create_inferior (exec_file, allargs, env)
+ char *exec_file;
+ char *allargs;
+ char **env;
+ {
+ if (!exec_file && !exec_bfd)
+ {
+ error ("No executable file specified.\n\
+ Use the \"file\" or \"exec-file\" command.");
+ return;
+ }
+
+ push_target (&linuxthreads_ops);
+ linuxthreads_breakpoints_inserted = 1;
+ linuxthreads_breakpoint_last = -1;
+ linuxthreads_wait_last = -1;
+ linuxthreads_exit_status = __W_STOPCODE(0);
+
+ if (linuxthreads_max)
+ linuxthreads_attach_pending = 1;
+
+ child_ops.to_create_inferior (exec_file, allargs, env);
+ }
+
+ /* Clean up after the inferior dies. */
+
+ static void
+ linuxthreads_mourn_inferior ()
+ {
+ if (linuxthreads_max)
+ {
+ int off = 0;
+ target_write_memory (linuxthreads_debug, (char *)&off, sizeof (off));
+
+ linuxthreads_inferior_pid = 0;
+ linuxthreads_breakpoint_pid = 0;
+ linuxthreads_step_pid = 0;
+ linuxthreads_step_signo = TARGET_SIGNAL_0;
+ linuxthreads_manager_pid = 0;
+ linuxthreads_initial_pid = 0;
+ linuxthreads_attach_pending = 0;
+ init_thread_list(); /* Destroy thread info */
+ }
+
+ child_ops.to_mourn_inferior ();
+
+ unpush_target (&linuxthreads_ops);
+ }
+
+ /* Kill the inferior process */
+
+ static void
+ linuxthreads_kill ()
+ {
+ int rpid;
+ int status;
+
+ if (inferior_pid == 0)
+ return;
+
+ if (linuxthreads_max && linuxthreads_manager_pid != 0)
+ {
+ /* Remove all threads status. */
+ inferior_pid = linuxthreads_manager_pid;
+ iterate_active_threads (kill_thread, 1);
+ }
+
+ kill_thread (inferior_pid);
+
+ #if 0
+ /* doing_quit_force solves a real problem, but I think a properly
+ placed call to catch_errors would do the trick much more cleanly. */
+ if (doing_quit_force >= 0)
+ {
+ if (linuxthreads_max && linuxthreads_manager_pid != 0)
+ {
+ /* Wait for thread to complete */
+ while ((rpid = waitpid (-1, &status, __WCLONE)) > 0)
+ if (!WIFEXITED(status))
+ kill_thread (rpid);
+
+ while ((rpid = waitpid (-1, &status, 0)) > 0)
+ if (!WIFEXITED(status))
+ kill_thread (rpid);
+ }
+ else
+ while ((rpid = waitpid (inferior_pid, &status, 0)) > 0)
+ if (!WIFEXITED(status))
+ ptrace (PT_KILL, inferior_pid, (PTRACE_ARG3_TYPE) 0, 0);
+ }
+ #endif
+
+ /* Wait for all threads. */
+ do
+ rpid = waitpid (-1, &status, __WCLONE | WNOHANG);
+ while (rpid > 0 || errno == EINTR);
+
+ do
+ rpid = waitpid (-1, &status, WNOHANG);
+ while (rpid > 0 || errno == EINTR);
+
+ linuxthreads_mourn_inferior ();
+ }
+
+ /* Insert a breakpoint */
+
+ static int
+ linuxthreads_insert_breakpoint (addr, contents_cache)
+ CORE_ADDR addr;
+ char *contents_cache;
+ {
+ if (linuxthreads_max && linuxthreads_manager_pid != 0)
+ {
+ linuxthreads_breakpoint_addr = addr;
+ iterate_active_threads (insert_breakpoint, 1);
+ insert_breakpoint (linuxthreads_manager_pid);
+ }
+
+ return child_ops.to_insert_breakpoint (addr, contents_cache);
+ }
+
+ /* Remove a breakpoint */
+
+ static int
+ linuxthreads_remove_breakpoint (addr, contents_cache)
+ CORE_ADDR addr;
+ char *contents_cache;
+ {
+ if (linuxthreads_max && linuxthreads_manager_pid != 0)
+ {
+ linuxthreads_breakpoint_addr = addr;
+ iterate_active_threads (remove_breakpoint, 1);
+ remove_breakpoint (linuxthreads_manager_pid);
+ }
+
+ return child_ops.to_remove_breakpoint (addr, contents_cache);
+ }
+
+ /* Mark our target-struct as eligible for stray "run" and "attach" commands. */
+
+ static int
+ linuxthreads_can_run ()
+ {
+ return child_suppress_run;
+ }
+
+ static void
+ init_linuxthreads_ops ()
+ {
+ linuxthreads_ops.to_shortname = "linuxthreads";
+ linuxthreads_ops.to_longname = "LINUX threads and pthread.";
+ linuxthreads_ops.to_doc = "LINUX threads and pthread support.";
+ linuxthreads_ops.to_attach = linuxthreads_attach;
+ linuxthreads_ops.to_detach = linuxthreads_detach;
+ linuxthreads_ops.to_resume = linuxthreads_resume;
+ linuxthreads_ops.to_wait = linuxthreads_wait;
+ linuxthreads_ops.to_kill = linuxthreads_kill;
+ linuxthreads_ops.to_can_run = linuxthreads_can_run;
+ linuxthreads_ops.to_stratum = thread_stratum;
+ linuxthreads_ops.to_insert_breakpoint = linuxthreads_insert_breakpoint;
+ linuxthreads_ops.to_remove_breakpoint = linuxthreads_remove_breakpoint;
+ linuxthreads_ops.to_create_inferior = linuxthreads_create_inferior;
+ linuxthreads_ops.to_mourn_inferior = linuxthreads_mourn_inferior;
+ linuxthreads_ops.to_thread_alive = linuxthreads_thread_alive;
+ linuxthreads_ops.to_magic = OPS_MAGIC;
+ }
+
+ void
+ _initialize_linuxthreads ()
+ {
+ struct sigaction sact;
+
+ init_linuxthreads_ops ();
+ add_target (&linuxthreads_ops);
+ child_suppress_run = 1;
+
+ /* Attach SIGCHLD handler */
+ sact.sa_handler = sigchld_handler;
+ sigemptyset (&sact.sa_mask);
+ sact.sa_flags = 0;
+ sigaction (SIGCHLD, &sact, NULL);
+
+ /* initialize SIGCHLD mask */
+ sigemptyset (&linuxthreads_wait_mask);
+ sigaddset (&linuxthreads_wait_mask, SIGCHLD);
+ }
diff -Ncr /home/kingdon/work/gdb/gdb/target.c ./gdb/target.c
*** /home/kingdon/work/gdb/gdb/target.c Thu Aug 12 11:13:38 1999
--- ./gdb/target.c Sat Aug 14 19:49:45 1999
***************
*** 1238,1243 ****
--- 1238,1244 ----
{"SIG61", "Real-time event 61"},
{"SIG62", "Real-time event 62"},
{"SIG63", "Real-time event 63"},
+ {"SIG32", "Real-time event 32"},
#if defined(MACH) || defined(__MACH__)
/* Mach exceptions */
***************
*** 1571,1578 ****
#if defined (REALTIME_LO)
if (hostsig >= REALTIME_LO && hostsig < REALTIME_HI)
! return (enum target_signal)
! (hostsig - 33 + (int) TARGET_SIGNAL_REALTIME_33);
#endif
return TARGET_SIGNAL_UNKNOWN;
}
--- 1572,1587 ----
#if defined (REALTIME_LO)
if (hostsig >= REALTIME_LO && hostsig < REALTIME_HI)
! {
! /* This block of TARGET_SIGNAL_REALTIME value is in order. */
! if (33 <= hostsig && hostsig <= 63)
! return (enum target_signal)
! (hostsig - 33 + (int) TARGET_SIGNAL_REALTIME_33);
! else if (hostsig == 32)
! return TARGET_SIGNAL_REALTIME_32;
! else
! error ("GDB bug: target.c (target_signal_from_host): unrecognized real-time signal");
! }
#endif
return TARGET_SIGNAL_UNKNOWN;
}
***************
*** 1619,1624 ****
--- 1628,1635 ----
case TARGET_SIGNAL_PRIO:
return SIGPRIO;
#endif
+
+ case TARGET_SIGNAL_REALTIME_32: return 32; /* by definition */
/* Mach exceptions. Assumes that the values for EXC_ are positive! */
#if defined (EXC_BAD_ACCESS) && defined (_NSIG)
diff -Ncr /home/kingdon/work/gdb/gdb/target.h ./gdb/target.h
*** /home/kingdon/work/gdb/gdb/target.h Thu Aug 12 11:13:38 1999
--- ./gdb/target.h Sat Aug 14 19:07:48 1999
***************
*** 48,54 ****
file_stratum, /* Executable files, etc */
core_stratum, /* Core dump files */
download_stratum, /* Downloading of remote targets */
! process_stratum /* Executing processes */
};
enum thread_control_capabilities {
--- 48,55 ----
file_stratum, /* Executable files, etc */
core_stratum, /* Core dump files */
download_stratum, /* Downloading of remote targets */
! process_stratum, /* Executing processes */
! thread_stratum /* Executing threads */
};
enum thread_control_capabilities {
***************
*** 214,219 ****
--- 215,227 ----
TARGET_EXC_SOFTWARE = 80,
TARGET_EXC_BREAKPOINT = 81,
#endif
+
+ /* Yes, this pains me, too. But LynxOS didn't have SIG32, and now
+ Linux does, and we can't disturb the numbering, since it's part
+ of the protocol. Note that in some GDB's TARGET_SIGNAL_REALTIME_32
+ is number 76. */
+ TARGET_SIGNAL_REALTIME_32,
+
/* Some signal we don't know about. */
TARGET_SIGNAL_UNKNOWN,