--- /dev/null
+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--; \
++ }
++
++
++ \f
++ #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;
++ }
++
++ \f
++ /* 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;
++ }
++
++
++ \f
++
++ /* 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;
++ }
++ \f
++ 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,
+
projects / packages / gdb.git / commitdiff