diff options
| -rw-r--r-- | gdb/ChangeLog | 35 | ||||
| -rw-r--r-- | gdb/Makefile.in | 5 | ||||
| -rw-r--r-- | gdb/config/alpha/alpha-linux.mh | 2 | ||||
| -rw-r--r-- | gdb/config/arm/linux.mh | 2 | ||||
| -rw-r--r-- | gdb/config/i386/linux.mh | 2 | ||||
| -rw-r--r-- | gdb/config/i386/linux64.mh | 2 | ||||
| -rw-r--r-- | gdb/config/ia64/linux.mh | 2 | ||||
| -rw-r--r-- | gdb/config/m68k/linux.mh | 2 | ||||
| -rw-r--r-- | gdb/config/mips/linux.mh | 2 | ||||
| -rw-r--r-- | gdb/config/pa/linux.mh | 2 | ||||
| -rw-r--r-- | gdb/config/powerpc/linux.mh | 2 | ||||
| -rw-r--r-- | gdb/config/powerpc/ppc64-linux.mh | 2 | ||||
| -rw-r--r-- | gdb/config/s390/s390.mh | 2 | ||||
| -rw-r--r-- | gdb/config/sparc/linux.mh | 2 | ||||
| -rw-r--r-- | gdb/config/sparc/linux64.mh | 2 | ||||
| -rw-r--r-- | gdb/lin-lwp.c | 1971 | ||||
| -rw-r--r-- | gdb/linux-nat.c | 1930 |
17 files changed, 1979 insertions, 1988 deletions
diff --git a/gdb/ChangeLog b/gdb/ChangeLog index b34e7a3..323dec4 100644 --- a/gdb/ChangeLog +++ b/gdb/ChangeLog @@ -1,3 +1,38 @@ +2004-09-16 Andrew Cagney <cagney@gnu.org> + + * lin-lwp.c: Delete file. + * linux-nat.c: Include "gdb_assert.h", "gdb_string.h", <unistd.h>, + <sys/syscall.h>, "gdbthread.h", "gdbcmd.h", "regcache.h". + (status_to_str, init_lwp_list, add_lwp, delete_lwp) + (find_lwp_pid, iterate_over_lwps, lin_lwp_attach_lwp) + (linux_nat_attach, detach_callback, linux_nat_detach) + (resume_callback, resume_clear_callback, linux_nat_resume) + (kill_lwp, linux_nat_handle_extended, wait_lwp, stop_callback) + (stop_wait_callback, linux_nat_has_pending, flush_callback) + (status_callback, running_callback, count_events_callback) + (select_singlestep_lwp_callback, select_event_lwp_callback) + (cancel_breakpoints_callback, select_event_lwp, resumed_callback) + (child_wait, stop_and_resume_callback, linux_nat_wait) + (kill_callback, kill_wait_callback, linux_nat_kill) + (linux_nat_create_inferior, linux_nat_mourn_inferior) + (linux_nat_xfer_memory, linux_nat_thread_alive) + (linux_nat_pid_to_str, init_linux_nat_ops, sigchld_handler) + (_initialize_linux_nat): New functions. + * Makefile.in: Update all dependencies. + * config/sparc/linux64.mh (NATDEPFILES): Remove lin-lwp.o. + * config/sparc/linux.mh (NATDEPFILES): Remove lin-lwp.o. + * config/s390/s390.mh (NATDEPFILES): Remove lin-lwp.o. + * config/powerpc/ppc64-linux.mh (NATDEPFILES): Remove lin-lwp.o. + * config/powerpc/linux.mh (NATDEPFILES): Remove lin-lwp.o. + * config/pa/linux.mh (NATDEPFILES): Remove lin-lwp.o. + * config/mips/linux.mh (NATDEPFILES): Remove lin-lwp.o. + * config/m68k/linux.mh (NATDEPFILES): Remove lin-lwp.o. + * config/ia64/linux.mh (NATDEPFILES): Remove lin-lwp.o. + * config/i386/linux64.mh (NATDEPFILES): Remove lin-lwp.o. + * config/i386/linux.mh (NATDEPFILES): Remove lin-lwp.o. + * config/arm/linux.mh (NATDEPFILES): Remove lin-lwp.o. + * config/alpha/alpha-linux.mh (NATDEPFILES): Remove lin-lwp.o. + 2004-09-27 Mark Kettenis <kettenis@gnu.org> * config/i386/fbsd64.mh, config/i386/nbsd64.mh, diff --git a/gdb/Makefile.in b/gdb/Makefile.in index 900c919..7f84623 100644 --- a/gdb/Makefile.in +++ b/gdb/Makefile.in @@ -2119,8 +2119,9 @@ linespec.o: linespec.c $(defs_h) $(symtab_h) $(frame_h) $(command_h) \ lin-lwp.o: lin-lwp.c $(defs_h) $(gdb_assert_h) $(gdb_string_h) $(gdb_wait_h) \ $(gdbthread_h) $(inferior_h) $(target_h) $(regcache_h) $(gdbcmd_h) \ $(linux_nat_h) -linux-nat.o: linux-nat.c $(defs_h) $(inferior_h) $(target_h) $(gdb_wait_h) \ - $(linux_nat_h) +linux-nat.o: linux-nat.c $(defs_h) $(inferior_h) $(target_h) $(gdb_string_h) \ + $(gdb_wait_h) $(gdb_assert_h) $(linux_nat_h) $(gdbthread_h) \ + $(gdbcmd_h) $(regcache_h) linux-proc.o: linux-proc.c $(defs_h) $(inferior_h) $(gdb_stat_h) \ $(regcache_h) $(gregset_h) $(gdbcore_h) $(gdbthread_h) $(elf_bfd_h) \ $(cli_decode_h) $(gdb_string_h) $(linux_nat_h) diff --git a/gdb/config/alpha/alpha-linux.mh b/gdb/config/alpha/alpha-linux.mh index d3cbff7..a927762 100644 --- a/gdb/config/alpha/alpha-linux.mh +++ b/gdb/config/alpha/alpha-linux.mh @@ -1,7 +1,7 @@ # Host: Little-endian Alpha running Linux NAT_FILE= nm-linux.h NATDEPFILES= infptrace.o inftarg.o corelow.o alpha-nat.o linux-proc.o \ - fork-child.o proc-service.o thread-db.o lin-lwp.o gcore.o \ + fork-child.o proc-service.o thread-db.o gcore.o \ linux-nat.o # The dynamically loaded libthread_db needs access to symbols in the diff --git a/gdb/config/arm/linux.mh b/gdb/config/arm/linux.mh index af5b546..aa252cf 100644 --- a/gdb/config/arm/linux.mh +++ b/gdb/config/arm/linux.mh @@ -3,7 +3,7 @@ NAT_FILE= nm-linux.h NATDEPFILES= infptrace.o inftarg.o fork-child.o corelow.o \ core-regset.o arm-linux-nat.o linux-proc.o gcore.o \ - proc-service.o thread-db.o lin-lwp.o linux-nat.o + proc-service.o thread-db.o linux-nat.o LOADLIBES= -ldl -rdynamic diff --git a/gdb/config/i386/linux.mh b/gdb/config/i386/linux.mh index 3714e0c..146b855 100644 --- a/gdb/config/i386/linux.mh +++ b/gdb/config/i386/linux.mh @@ -3,7 +3,7 @@ NAT_FILE= nm-linux.h NATDEPFILES= infptrace.o inftarg.o fork-child.o corelow.o linux-proc.o \ core-aout.o i386-nat.o i386-linux-nat.o \ - proc-service.o thread-db.o lin-lwp.o linux-proc.o gcore.o \ + proc-service.o thread-db.o linux-proc.o gcore.o \ linux-nat.o # The dynamically loaded libthread_db needs access to symbols in the diff --git a/gdb/config/i386/linux64.mh b/gdb/config/i386/linux64.mh index 1622f18..9fbba56 100644 --- a/gdb/config/i386/linux64.mh +++ b/gdb/config/i386/linux64.mh @@ -1,7 +1,7 @@ # Host: GNU/Linux x86-64 NATDEPFILES= infptrace.o inftarg.o fork-child.o \ i386-nat.o amd64-nat.o amd64-linux-nat.o linux-nat.o \ - proc-service.o thread-db.o lin-lwp.o linux-proc.o gcore.o + proc-service.o thread-db.o linux-proc.o gcore.o NAT_FILE= nm-linux64.h # The dynamically loaded libthread_db needs access to symbols in the diff --git a/gdb/config/ia64/linux.mh b/gdb/config/ia64/linux.mh index 71fed10..2468c67 100644 --- a/gdb/config/ia64/linux.mh +++ b/gdb/config/ia64/linux.mh @@ -3,6 +3,6 @@ NAT_FILE= nm-linux.h NATDEPFILES= infptrace.o inftarg.o fork-child.o corelow.o gcore.o \ core-aout.o core-regset.o ia64-linux-nat.o linux-proc.o \ - proc-service.o thread-db.o lin-lwp.o linux-nat.o + proc-service.o thread-db.o linux-nat.o LOADLIBES = -ldl -rdynamic diff --git a/gdb/config/m68k/linux.mh b/gdb/config/m68k/linux.mh index 69dce24..42231d9 100644 --- a/gdb/config/m68k/linux.mh +++ b/gdb/config/m68k/linux.mh @@ -3,7 +3,7 @@ NAT_FILE= nm-linux.h NATDEPFILES= infptrace.o inftarg.o fork-child.o \ corelow.o core-aout.o m68klinux-nat.o linux-proc.o gcore.o \ - proc-service.o thread-db.o lin-lwp.o linux-nat.o + proc-service.o thread-db.o linux-nat.o # The dynamically loaded libthread_db needs access to symbols in the # gdb executable. diff --git a/gdb/config/mips/linux.mh b/gdb/config/mips/linux.mh index 3fbc3e9..d282c96 100644 --- a/gdb/config/mips/linux.mh +++ b/gdb/config/mips/linux.mh @@ -1,7 +1,7 @@ # Host: Linux/MIPS NAT_FILE= nm-linux.h NATDEPFILES= infptrace.o inftarg.o fork-child.o mips-linux-nat.o \ - thread-db.o lin-lwp.o proc-service.o linux-proc.o gcore.o \ + thread-db.o proc-service.o linux-proc.o gcore.o \ linux-nat.o LOADLIBES = -ldl -rdynamic diff --git a/gdb/config/pa/linux.mh b/gdb/config/pa/linux.mh index 596857c..7553d24 100644 --- a/gdb/config/pa/linux.mh +++ b/gdb/config/pa/linux.mh @@ -3,6 +3,6 @@ XDEPFILES= NAT_FILE= nm-linux.h NATDEPFILES= infptrace.o inftarg.o fork-child.o corelow.o gcore.o \ core-regset.o hppa-linux-nat.o linux-proc.o \ - proc-service.o thread-db.o lin-lwp.o linux-nat.o + proc-service.o thread-db.o linux-nat.o LOADLIBES = -ldl -rdynamic diff --git a/gdb/config/powerpc/linux.mh b/gdb/config/powerpc/linux.mh index 450a777..a207d32 100644 --- a/gdb/config/powerpc/linux.mh +++ b/gdb/config/powerpc/linux.mh @@ -4,7 +4,7 @@ XM_CLIBS= NAT_FILE= nm-linux.h NATDEPFILES= infptrace.o inftarg.o fork-child.o linux-proc.o \ - ppc-linux-nat.o proc-service.o thread-db.o lin-lwp.o \ + ppc-linux-nat.o proc-service.o thread-db.o \ gcore.o linux-nat.o LOADLIBES = -ldl -rdynamic diff --git a/gdb/config/powerpc/ppc64-linux.mh b/gdb/config/powerpc/ppc64-linux.mh index b22408a..4c35f3b 100644 --- a/gdb/config/powerpc/ppc64-linux.mh +++ b/gdb/config/powerpc/ppc64-linux.mh @@ -4,7 +4,7 @@ XM_CLIBS= NAT_FILE= nm-ppc64-linux.h NATDEPFILES= infptrace.o inftarg.o fork-child.o linux-proc.o \ - ppc-linux-nat.o proc-service.o thread-db.o lin-lwp.o \ + ppc-linux-nat.o proc-service.o thread-db.o \ gcore.o linux-nat.o # The PowerPC has severe limitations on TOC size, and uses them even diff --git a/gdb/config/s390/s390.mh b/gdb/config/s390/s390.mh index 3db7bd9..7bf24f8 100644 --- a/gdb/config/s390/s390.mh +++ b/gdb/config/s390/s390.mh @@ -1,5 +1,5 @@ # Host: S390, running Linux NAT_FILE= nm-linux.h NATDEPFILES= infptrace.o inftarg.o fork-child.o corelow.o s390-nat.o \ - linux-proc.o gcore.o thread-db.o lin-lwp.o proc-service.o linux-nat.o + linux-proc.o gcore.o thread-db.o proc-service.o linux-nat.o LOADLIBES = -ldl -rdynamic diff --git a/gdb/config/sparc/linux.mh b/gdb/config/sparc/linux.mh index ed68cc7..bc0644f 100644 --- a/gdb/config/sparc/linux.mh +++ b/gdb/config/sparc/linux.mh @@ -3,7 +3,7 @@ NAT_FILE= nm-linux.h NATDEPFILES= sparc-nat.o sparc-sol2-nat.o \ corelow.o core-regset.o fork-child.o \ infptrace.o inftarg.o \ - proc-service.o thread-db.o lin-lwp.o \ + proc-service.o thread-db.o \ linux-proc.o gcore.o linux-nat.o # The dynamically loaded libthread_db needs access to symbols in the diff --git a/gdb/config/sparc/linux64.mh b/gdb/config/sparc/linux64.mh index c1472de..0cc8f01 100644 --- a/gdb/config/sparc/linux64.mh +++ b/gdb/config/sparc/linux64.mh @@ -3,7 +3,7 @@ NAT_FILE= nm-linux.h NATDEPFILES= sparc-nat.o sparc64-nat.o sparc-sol2-nat.o sparc64-linux-nat.o \ corelow.o core-regset.o \ fork-child.o infptrace.o inftarg.o \ - proc-service.o thread-db.o lin-lwp.o \ + proc-service.o thread-db.o \ linux-proc.o gcore.o linux-nat.o # The dynamically loaded libthread_db needs access to symbols in the diff --git a/gdb/lin-lwp.c b/gdb/lin-lwp.c deleted file mode 100644 index 5971630..0000000 --- a/gdb/lin-lwp.c +++ /dev/null @@ -1,1971 +0,0 @@ -/* Multi-threaded debugging support for GNU/Linux (LWP layer). - Copyright 2000, 2001, 2002, 2003, 2004 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. */ - -#include "defs.h" - -#include "gdb_assert.h" -#include "gdb_string.h" -#include <errno.h> -#include <signal.h> -#ifdef HAVE_TKILL_SYSCALL -#include <unistd.h> -#include <sys/syscall.h> -#endif -#include <sys/ptrace.h> -#include "gdb_wait.h" - -#include "gdbthread.h" -#include "inferior.h" -#include "target.h" -#include "regcache.h" -#include "gdbcmd.h" - -static int debug_lin_lwp; -extern char *strsignal (int sig); - -#include "linux-nat.h" - -/* On GNU/Linux there are no real LWP's. The closest thing to LWP's - are processes sharing the same VM space. A multi-threaded process - is basically a group of such processes. However, such a grouping - is almost entirely a user-space issue; the kernel doesn't enforce - such a grouping at all (this might change in the future). In - general, we'll rely on the threads library (i.e. the GNU/Linux - Threads library) to provide such a grouping. - - It is perfectly well possible to write a multi-threaded application - without the assistance of a threads library, by using the clone - system call directly. This module should be able to give some - rudimentary support for debugging such applications if developers - specify the CLONE_PTRACE flag in the clone system call, and are - using the Linux kernel 2.4 or above. - - Note that there are some peculiarities in GNU/Linux that affect - this code: - - - In general one should specify the __WCLONE flag to waitpid in - order to make it report events for any of the cloned processes - (and leave it out for the initial process). However, if a cloned - process has exited the exit status is only reported if the - __WCLONE flag is absent. Linux kernel 2.4 has a __WALL flag, but - we cannot use it since GDB must work on older systems too. - - - When a traced, cloned process exits and is waited for by the - debugger, the kernel reassigns it to the original parent and - keeps it around as a "zombie". Somehow, the GNU/Linux Threads - library doesn't notice this, which leads to the "zombie problem": - When debugged a multi-threaded process that spawns a lot of - threads will run out of processes, even if the threads exit, - because the "zombies" stay around. */ - -/* List of known LWPs. */ -static struct lwp_info *lwp_list; - -/* Number of LWPs in the list. */ -static int num_lwps; - -/* Non-zero if we're running in "threaded" mode. */ -static int threaded; - - -#define GET_LWP(ptid) ptid_get_lwp (ptid) -#define GET_PID(ptid) ptid_get_pid (ptid) -#define is_lwp(ptid) (GET_LWP (ptid) != 0) -#define BUILD_LWP(lwp, pid) ptid_build (pid, lwp, 0) - -/* If the last reported event was a SIGTRAP, this variable is set to - the process id of the LWP/thread that got it. */ -ptid_t trap_ptid; - - -/* This module's target-specific operations. */ -static struct target_ops lin_lwp_ops; - -/* The standard child operations. */ -extern struct target_ops child_ops; - -/* Since we cannot wait (in lin_lwp_wait) for the initial process and - any cloned processes with a single call to waitpid, we have to use - the WNOHANG flag and call waitpid in a loop. To optimize - things a bit we use `sigsuspend' to wake us up when a process has - something to report (it will send us a SIGCHLD if it has). To make - this work we have to juggle with the signal mask. We save the - original signal mask such that we can restore it before creating a - new process in order to avoid blocking certain signals in the - inferior. We then block SIGCHLD during the waitpid/sigsuspend - loop. */ - -/* Original signal mask. */ -static sigset_t normal_mask; - -/* Signal mask for use with sigsuspend in lin_lwp_wait, initialized in - _initialize_lin_lwp. */ -static sigset_t suspend_mask; - -/* Signals to block to make that sigsuspend work. */ -static sigset_t blocked_mask; - - -/* Prototypes for local functions. */ -static int stop_wait_callback (struct lwp_info *lp, void *data); -static int lin_lwp_thread_alive (ptid_t ptid); - -/* Convert wait status STATUS to a string. Used for printing debug - messages only. */ - -static char * -status_to_str (int status) -{ - static char buf[64]; - - if (WIFSTOPPED (status)) - snprintf (buf, sizeof (buf), "%s (stopped)", - strsignal (WSTOPSIG (status))); - else if (WIFSIGNALED (status)) - snprintf (buf, sizeof (buf), "%s (terminated)", - strsignal (WSTOPSIG (status))); - else - snprintf (buf, sizeof (buf), "%d (exited)", WEXITSTATUS (status)); - - return buf; -} - -/* Initialize the list of LWPs. Note that this module, contrary to - what GDB's generic threads layer does for its thread list, - re-initializes the LWP lists whenever we mourn or detach (which - doesn't involve mourning) the inferior. */ - -static void -init_lwp_list (void) -{ - struct lwp_info *lp, *lpnext; - - for (lp = lwp_list; lp; lp = lpnext) - { - lpnext = lp->next; - xfree (lp); - } - - lwp_list = NULL; - num_lwps = 0; - threaded = 0; -} - -/* Add the LWP specified by PID to the list. If this causes the - number of LWPs to become larger than one, go into "threaded" mode. - Return a pointer to the structure describing the new LWP. */ - -static struct lwp_info * -add_lwp (ptid_t ptid) -{ - struct lwp_info *lp; - - gdb_assert (is_lwp (ptid)); - - lp = (struct lwp_info *) xmalloc (sizeof (struct lwp_info)); - - memset (lp, 0, sizeof (struct lwp_info)); - - lp->waitstatus.kind = TARGET_WAITKIND_IGNORE; - - lp->ptid = ptid; - - lp->next = lwp_list; - lwp_list = lp; - if (++num_lwps > 1) - threaded = 1; - - return lp; -} - -/* Remove the LWP specified by PID from the list. */ - -static void -delete_lwp (ptid_t ptid) -{ - struct lwp_info *lp, *lpprev; - - lpprev = NULL; - - for (lp = lwp_list; lp; lpprev = lp, lp = lp->next) - if (ptid_equal (lp->ptid, ptid)) - break; - - if (!lp) - return; - - /* We don't go back to "non-threaded" mode if the number of threads - becomes less than two. */ - num_lwps--; - - if (lpprev) - lpprev->next = lp->next; - else - lwp_list = lp->next; - - xfree (lp); -} - -/* Return a pointer to the structure describing the LWP corresponding - to PID. If no corresponding LWP could be found, return NULL. */ - -static struct lwp_info * -find_lwp_pid (ptid_t ptid) -{ - struct lwp_info *lp; - int lwp; - - if (is_lwp (ptid)) - lwp = GET_LWP (ptid); - else - lwp = GET_PID (ptid); - - for (lp = lwp_list; lp; lp = lp->next) - if (lwp == GET_LWP (lp->ptid)) - return lp; - - return NULL; -} - -/* Call CALLBACK with its second argument set to DATA for every LWP in - the list. If CALLBACK returns 1 for a particular LWP, return a - pointer to the structure describing that LWP immediately. - Otherwise return NULL. */ - -struct lwp_info * -iterate_over_lwps (int (*callback) (struct lwp_info *, void *), void *data) -{ - struct lwp_info *lp, *lpnext; - - for (lp = lwp_list; lp; lp = lpnext) - { - lpnext = lp->next; - if ((*callback) (lp, data)) - return lp; - } - - return NULL; -} - - -#if 0 -static void -lin_lwp_open (char *args, int from_tty) -{ - push_target (&lin_lwp_ops); -} -#endif - -/* Attach to the LWP specified by PID. If VERBOSE is non-zero, print - a message telling the user that a new LWP has been added to the - process. */ - -void -lin_lwp_attach_lwp (ptid_t ptid, int verbose) -{ - struct lwp_info *lp, *found_lp; - - gdb_assert (is_lwp (ptid)); - - /* Make sure SIGCHLD is blocked. We don't want SIGCHLD events - to interrupt either the ptrace() or waitpid() calls below. */ - if (!sigismember (&blocked_mask, SIGCHLD)) - { - sigaddset (&blocked_mask, SIGCHLD); - sigprocmask (SIG_BLOCK, &blocked_mask, NULL); - } - - if (verbose) - printf_filtered ("[New %s]\n", target_pid_to_str (ptid)); - - found_lp = lp = find_lwp_pid (ptid); - if (lp == NULL) - lp = add_lwp (ptid); - - /* We assume that we're already attached to any LWP that has an id - equal to the overall process id, and to any LWP that is already - in our list of LWPs. If we're not seeing exit events from threads - and we've had PID wraparound since we last tried to stop all threads, - this assumption might be wrong; fortunately, this is very unlikely - to happen. */ - if (GET_LWP (ptid) != GET_PID (ptid) && found_lp == NULL) - { - pid_t pid; - int status; - - if (ptrace (PTRACE_ATTACH, GET_LWP (ptid), 0, 0) < 0) - error ("Can't attach %s: %s", target_pid_to_str (ptid), - safe_strerror (errno)); - - if (debug_lin_lwp) - fprintf_unfiltered (gdb_stdlog, - "LLAL: PTRACE_ATTACH %s, 0, 0 (OK)\n", - target_pid_to_str (ptid)); - - pid = waitpid (GET_LWP (ptid), &status, 0); - if (pid == -1 && errno == ECHILD) - { - /* Try again with __WCLONE to check cloned processes. */ - pid = waitpid (GET_LWP (ptid), &status, __WCLONE); - lp->cloned = 1; - } - - gdb_assert (pid == GET_LWP (ptid) - && WIFSTOPPED (status) && WSTOPSIG (status)); - - child_post_attach (pid); - - lp->stopped = 1; - - if (debug_lin_lwp) - { - fprintf_unfiltered (gdb_stdlog, - "LLAL: waitpid %s received %s\n", - target_pid_to_str (ptid), - status_to_str (status)); - } - } - else - { - /* We assume that the LWP representing the original process - is already stopped. Mark it as stopped in the data structure - that the lin-lwp layer uses to keep track of threads. Note - that this won't have already been done since the main thread - will have, we assume, been stopped by an attach from a - different layer. */ - lp->stopped = 1; - } -} - -static void -lin_lwp_attach (char *args, int from_tty) -{ - struct lwp_info *lp; - pid_t pid; - int status; - - /* FIXME: We should probably accept a list of process id's, and - attach all of them. */ - child_ops.to_attach (args, from_tty); - - /* Add the initial process as the first LWP to the list. */ - lp = add_lwp (BUILD_LWP (GET_PID (inferior_ptid), GET_PID (inferior_ptid))); - - /* Make sure the initial process is stopped. The user-level threads - layer might want to poke around in the inferior, and that won't - work if things haven't stabilized yet. */ - pid = waitpid (GET_PID (inferior_ptid), &status, 0); - if (pid == -1 && errno == ECHILD) - { - warning ("%s is a cloned process", target_pid_to_str (inferior_ptid)); - - /* Try again with __WCLONE to check cloned processes. */ - pid = waitpid (GET_PID (inferior_ptid), &status, __WCLONE); - lp->cloned = 1; - } - - gdb_assert (pid == GET_PID (inferior_ptid) - && WIFSTOPPED (status) && WSTOPSIG (status) == SIGSTOP); - - lp->stopped = 1; - - /* Fake the SIGSTOP that core GDB expects. */ - lp->status = W_STOPCODE (SIGSTOP); - lp->resumed = 1; - if (debug_lin_lwp) - { - fprintf_unfiltered (gdb_stdlog, - "LLA: waitpid %ld, faking SIGSTOP\n", (long) pid); - } -} - -static int -detach_callback (struct lwp_info *lp, void *data) -{ - gdb_assert (lp->status == 0 || WIFSTOPPED (lp->status)); - - if (debug_lin_lwp && lp->status) - fprintf_unfiltered (gdb_stdlog, "DC: Pending %s for %s on detach.\n", - strsignal (WSTOPSIG (lp->status)), - target_pid_to_str (lp->ptid)); - - while (lp->signalled && lp->stopped) - { - errno = 0; - if (ptrace (PTRACE_CONT, GET_LWP (lp->ptid), 0, - WSTOPSIG (lp->status)) < 0) - error ("Can't continue %s: %s", target_pid_to_str (lp->ptid), - safe_strerror (errno)); - - if (debug_lin_lwp) - fprintf_unfiltered (gdb_stdlog, - "DC: PTRACE_CONTINUE (%s, 0, %s) (OK)\n", - target_pid_to_str (lp->ptid), - status_to_str (lp->status)); - - lp->stopped = 0; - lp->signalled = 0; - lp->status = 0; - /* FIXME drow/2003-08-26: There was a call to stop_wait_callback - here. But since lp->signalled was cleared above, - stop_wait_callback didn't do anything; the process was left - running. Shouldn't we be waiting for it to stop? - I've removed the call, since stop_wait_callback now does do - something when called with lp->signalled == 0. */ - - gdb_assert (lp->status == 0 || WIFSTOPPED (lp->status)); - } - - /* We don't actually detach from the LWP that has an id equal to the - overall process id just yet. */ - if (GET_LWP (lp->ptid) != GET_PID (lp->ptid)) - { - errno = 0; - if (ptrace (PTRACE_DETACH, GET_LWP (lp->ptid), 0, - WSTOPSIG (lp->status)) < 0) - error ("Can't detach %s: %s", target_pid_to_str (lp->ptid), - safe_strerror (errno)); - - if (debug_lin_lwp) - fprintf_unfiltered (gdb_stdlog, - "PTRACE_DETACH (%s, %s, 0) (OK)\n", - target_pid_to_str (lp->ptid), - strsignal (WSTOPSIG (lp->status))); - - delete_lwp (lp->ptid); - } - - return 0; -} - -static void -lin_lwp_detach (char *args, int from_tty) -{ - iterate_over_lwps (detach_callback, NULL); - - /* Only the initial process should be left right now. */ - gdb_assert (num_lwps == 1); - - trap_ptid = null_ptid; - - /* Destroy LWP info; it's no longer valid. */ - init_lwp_list (); - - /* Restore the original signal mask. */ - sigprocmask (SIG_SETMASK, &normal_mask, NULL); - sigemptyset (&blocked_mask); - - inferior_ptid = pid_to_ptid (GET_PID (inferior_ptid)); - child_ops.to_detach (args, from_tty); -} - - -/* Resume LP. */ - -static int -resume_callback (struct lwp_info *lp, void *data) -{ - if (lp->stopped && lp->status == 0) - { - struct thread_info *tp; - - child_resume (pid_to_ptid (GET_LWP (lp->ptid)), 0, TARGET_SIGNAL_0); - if (debug_lin_lwp) - fprintf_unfiltered (gdb_stdlog, - "RC: PTRACE_CONT %s, 0, 0 (resume sibling)\n", - target_pid_to_str (lp->ptid)); - lp->stopped = 0; - lp->step = 0; - } - - return 0; -} - -static int -resume_clear_callback (struct lwp_info *lp, void *data) -{ - lp->resumed = 0; - return 0; -} - -static int -resume_set_callback (struct lwp_info *lp, void *data) -{ - lp->resumed = 1; - return 0; -} - -static void -lin_lwp_resume (ptid_t ptid, int step, enum target_signal signo) -{ - struct lwp_info *lp; - int resume_all; - - /* A specific PTID means `step only this process id'. */ - resume_all = (PIDGET (ptid) == -1); - - if (resume_all) - iterate_over_lwps (resume_set_callback, NULL); - else - iterate_over_lwps (resume_clear_callback, NULL); - - /* If PID is -1, it's the current inferior that should be - handled specially. */ - if (PIDGET (ptid) == -1) - ptid = inferior_ptid; - - lp = find_lwp_pid (ptid); - if (lp) - { - ptid = pid_to_ptid (GET_LWP (lp->ptid)); - - /* Remember if we're stepping. */ - lp->step = step; - - /* Mark this LWP as resumed. */ - lp->resumed = 1; - - /* If we have a pending wait status for this thread, there is no - point in resuming the process. */ - if (lp->status) - { - /* FIXME: What should we do if we are supposed to continue - this thread with a signal? */ - gdb_assert (signo == TARGET_SIGNAL_0); - return; - } - - /* Mark LWP as not stopped to prevent it from being continued by - resume_callback. */ - lp->stopped = 0; - } - - if (resume_all) - iterate_over_lwps (resume_callback, NULL); - - child_resume (ptid, step, signo); - if (debug_lin_lwp) - fprintf_unfiltered (gdb_stdlog, - "LLR: %s %s, %s (resume event thread)\n", - step ? "PTRACE_SINGLESTEP" : "PTRACE_CONT", - target_pid_to_str (ptid), - signo ? strsignal (signo) : "0"); -} - - -/* Issue kill to specified lwp. */ - -static int tkill_failed; - -static int -kill_lwp (int lwpid, int signo) -{ - errno = 0; - -/* Use tkill, if possible, in case we are using nptl threads. If tkill - fails, then we are not using nptl threads and we should be using kill. */ - -#ifdef HAVE_TKILL_SYSCALL - if (!tkill_failed) - { - int ret = syscall (__NR_tkill, lwpid, signo); - if (errno != ENOSYS) - return ret; - errno = 0; - tkill_failed = 1; - } -#endif - - return kill (lwpid, signo); -} - -/* Handle a GNU/Linux extended wait response. Most of the work we - just pass off to linux_handle_extended_wait, but if it reports a - clone event we need to add the new LWP to our list (and not report - the trap to higher layers). This function returns non-zero if - the event should be ignored and we should wait again. */ - -static int -lin_lwp_handle_extended (struct lwp_info *lp, int status) -{ - linux_handle_extended_wait (GET_LWP (lp->ptid), status, - &lp->waitstatus); - - /* TARGET_WAITKIND_SPURIOUS is used to indicate clone events. */ - if (lp->waitstatus.kind == TARGET_WAITKIND_SPURIOUS) - { - struct lwp_info *new_lp; - new_lp = add_lwp (BUILD_LWP (lp->waitstatus.value.related_pid, - GET_PID (inferior_ptid))); - new_lp->cloned = 1; - new_lp->stopped = 1; - - lp->waitstatus.kind = TARGET_WAITKIND_IGNORE; - - if (debug_lin_lwp) - fprintf_unfiltered (gdb_stdlog, - "LLHE: Got clone event from LWP %ld, resuming\n", - GET_LWP (lp->ptid)); - ptrace (PTRACE_CONT, GET_LWP (lp->ptid), 0, 0); - - return 1; - } - - return 0; -} - -/* Wait for LP to stop. Returns the wait status, or 0 if the LWP has - exited. */ - -static int -wait_lwp (struct lwp_info *lp) -{ - pid_t pid; - int status; - int thread_dead = 0; - - gdb_assert (!lp->stopped); - gdb_assert (lp->status == 0); - - pid = waitpid (GET_LWP (lp->ptid), &status, 0); - if (pid == -1 && errno == ECHILD) - { - pid = waitpid (GET_LWP (lp->ptid), &status, __WCLONE); - if (pid == -1 && errno == ECHILD) - { - /* The thread has previously exited. We need to delete it - now because, for some vendor 2.4 kernels with NPTL - support backported, there won't be an exit event unless - it is the main thread. 2.6 kernels will report an exit - event for each thread that exits, as expected. */ - thread_dead = 1; - if (debug_lin_lwp) - fprintf_unfiltered (gdb_stdlog, "WL: %s vanished.\n", - target_pid_to_str (lp->ptid)); - } - } - - if (!thread_dead) - { - gdb_assert (pid == GET_LWP (lp->ptid)); - - if (debug_lin_lwp) - { - fprintf_unfiltered (gdb_stdlog, - "WL: waitpid %s received %s\n", - target_pid_to_str (lp->ptid), - status_to_str (status)); - } - } - - /* Check if the thread has exited. */ - if (WIFEXITED (status) || WIFSIGNALED (status)) - { - thread_dead = 1; - if (debug_lin_lwp) - fprintf_unfiltered (gdb_stdlog, "WL: %s exited.\n", - target_pid_to_str (lp->ptid)); - } - - if (thread_dead) - { - if (in_thread_list (lp->ptid)) - { - /* Core GDB cannot deal with us deleting the current thread. */ - if (!ptid_equal (lp->ptid, inferior_ptid)) - delete_thread (lp->ptid); - printf_unfiltered ("[%s exited]\n", - target_pid_to_str (lp->ptid)); - } - - delete_lwp (lp->ptid); - return 0; - } - - gdb_assert (WIFSTOPPED (status)); - - /* Handle GNU/Linux's extended waitstatus for trace events. */ - if (WIFSTOPPED (status) && WSTOPSIG (status) == SIGTRAP && status >> 16 != 0) - { - if (debug_lin_lwp) - fprintf_unfiltered (gdb_stdlog, - "WL: Handling extended status 0x%06x\n", - status); - if (lin_lwp_handle_extended (lp, status)) - return wait_lwp (lp); - } - - return status; -} - -/* Send a SIGSTOP to LP. */ - -static int -stop_callback (struct lwp_info *lp, void *data) -{ - if (!lp->stopped && !lp->signalled) - { - int ret; - - if (debug_lin_lwp) - { - fprintf_unfiltered (gdb_stdlog, - "SC: kill %s **<SIGSTOP>**\n", - target_pid_to_str (lp->ptid)); - } - errno = 0; - ret = kill_lwp (GET_LWP (lp->ptid), SIGSTOP); - if (debug_lin_lwp) - { - fprintf_unfiltered (gdb_stdlog, - "SC: lwp kill %d %s\n", - ret, - errno ? safe_strerror (errno) : "ERRNO-OK"); - } - - lp->signalled = 1; - gdb_assert (lp->status == 0); - } - - return 0; -} - -/* Wait until LP is stopped. If DATA is non-null it is interpreted as - a pointer to a set of signals to be flushed immediately. */ - -static int -stop_wait_callback (struct lwp_info *lp, void *data) -{ - sigset_t *flush_mask = data; - - if (!lp->stopped) - { - int status; - - status = wait_lwp (lp); - if (status == 0) - return 0; - - /* Ignore any signals in FLUSH_MASK. */ - if (flush_mask && sigismember (flush_mask, WSTOPSIG (status))) - { - if (!lp->signalled) - { - lp->stopped = 1; - return 0; - } - - errno = 0; - ptrace (PTRACE_CONT, GET_LWP (lp->ptid), 0, 0); - if (debug_lin_lwp) - fprintf_unfiltered (gdb_stdlog, - "PTRACE_CONT %s, 0, 0 (%s)\n", - target_pid_to_str (lp->ptid), - errno ? safe_strerror (errno) : "OK"); - - return stop_wait_callback (lp, flush_mask); - } - - if (WSTOPSIG (status) != SIGSTOP) - { - if (WSTOPSIG (status) == SIGTRAP) - { - /* If a LWP other than the LWP that we're reporting an - event for has hit a GDB breakpoint (as opposed to - some random trap signal), then just arrange for it to - hit it again later. We don't keep the SIGTRAP status - and don't forward the SIGTRAP signal to the LWP. We - will handle the current event, eventually we will - resume all LWPs, and this one will get its breakpoint - trap again. - - If we do not do this, then we run the risk that the - user will delete or disable the breakpoint, but the - thread will have already tripped on it. */ - - /* Now resume this LWP and get the SIGSTOP event. */ - errno = 0; - ptrace (PTRACE_CONT, GET_LWP (lp->ptid), 0, 0); - if (debug_lin_lwp) - { - fprintf_unfiltered (gdb_stdlog, - "PTRACE_CONT %s, 0, 0 (%s)\n", - target_pid_to_str (lp->ptid), - errno ? safe_strerror (errno) : "OK"); - - fprintf_unfiltered (gdb_stdlog, - "SWC: Candidate SIGTRAP event in %s\n", - target_pid_to_str (lp->ptid)); - } - /* Hold the SIGTRAP for handling by lin_lwp_wait. */ - stop_wait_callback (lp, data); - /* If there's another event, throw it back into the queue. */ - if (lp->status) - { - if (debug_lin_lwp) - { - fprintf_unfiltered (gdb_stdlog, - "SWC: kill %s, %s\n", - target_pid_to_str (lp->ptid), - status_to_str ((int) status)); - } - kill_lwp (GET_LWP (lp->ptid), WSTOPSIG (lp->status)); - } - /* Save the sigtrap event. */ - lp->status = status; - return 0; - } - else - { - /* The thread was stopped with a signal other than - SIGSTOP, and didn't accidentally trip a breakpoint. */ - - if (debug_lin_lwp) - { - fprintf_unfiltered (gdb_stdlog, - "SWC: Pending event %s in %s\n", - status_to_str ((int) status), - target_pid_to_str (lp->ptid)); - } - /* Now resume this LWP and get the SIGSTOP event. */ - errno = 0; - ptrace (PTRACE_CONT, GET_LWP (lp->ptid), 0, 0); - if (debug_lin_lwp) - fprintf_unfiltered (gdb_stdlog, - "SWC: PTRACE_CONT %s, 0, 0 (%s)\n", - target_pid_to_str (lp->ptid), - errno ? safe_strerror (errno) : "OK"); - - /* Hold this event/waitstatus while we check to see if - there are any more (we still want to get that SIGSTOP). */ - stop_wait_callback (lp, data); - /* If the lp->status field is still empty, use it to hold - this event. If not, then this event must be returned - to the event queue of the LWP. */ - if (lp->status == 0) - lp->status = status; - else - { - if (debug_lin_lwp) - { - fprintf_unfiltered (gdb_stdlog, - "SWC: kill %s, %s\n", - target_pid_to_str (lp->ptid), - status_to_str ((int) status)); - } - kill_lwp (GET_LWP (lp->ptid), WSTOPSIG (status)); - } - return 0; - } - } - else - { - /* We caught the SIGSTOP that we intended to catch, so - there's no SIGSTOP pending. */ - lp->stopped = 1; - lp->signalled = 0; - } - } - - return 0; -} - -/* Check whether PID has any pending signals in FLUSH_MASK. If so set - the appropriate bits in PENDING, and return 1 - otherwise return 0. */ - -static int -lin_lwp_has_pending (int pid, sigset_t *pending, sigset_t *flush_mask) -{ - sigset_t blocked, ignored; - int i; - - linux_proc_pending_signals (pid, pending, &blocked, &ignored); - - if (!flush_mask) - return 0; - - for (i = 1; i < NSIG; i++) - if (sigismember (pending, i)) - if (!sigismember (flush_mask, i) - || sigismember (&blocked, i) - || sigismember (&ignored, i)) - sigdelset (pending, i); - - if (sigisemptyset (pending)) - return 0; - - return 1; -} - -/* DATA is interpreted as a mask of signals to flush. If LP has - signals pending, and they are all in the flush mask, then arrange - to flush them. LP should be stopped, as should all other threads - it might share a signal queue with. */ - -static int -flush_callback (struct lwp_info *lp, void *data) -{ - sigset_t *flush_mask = data; - sigset_t pending, intersection, blocked, ignored; - int pid, status; - - /* Normally, when an LWP exits, it is removed from the LWP list. The - last LWP isn't removed till later, however. So if there is only - one LWP on the list, make sure it's alive. */ - if (lwp_list == lp && lp->next == NULL) - if (!lin_lwp_thread_alive (lp->ptid)) - return 0; - - /* Just because the LWP is stopped doesn't mean that new signals - can't arrive from outside, so this function must be careful of - race conditions. However, because all threads are stopped, we - can assume that the pending mask will not shrink unless we resume - the LWP, and that it will then get another signal. We can't - control which one, however. */ - - if (lp->status) - { - if (debug_lin_lwp) - printf_unfiltered ("FC: LP has pending status %06x\n", lp->status); - if (WIFSTOPPED (lp->status) && sigismember (flush_mask, WSTOPSIG (lp->status))) - lp->status = 0; - } - - while (lin_lwp_has_pending (GET_LWP (lp->ptid), &pending, flush_mask)) - { - int ret; - - errno = 0; - ret = ptrace (PTRACE_CONT, GET_LWP (lp->ptid), 0, 0); - if (debug_lin_lwp) - fprintf_unfiltered (gdb_stderr, - "FC: Sent PTRACE_CONT, ret %d %d\n", ret, errno); - - lp->stopped = 0; - stop_wait_callback (lp, flush_mask); - if (debug_lin_lwp) - fprintf_unfiltered (gdb_stderr, - "FC: Wait finished; saved status is %d\n", - lp->status); - } - - return 0; -} - -/* Return non-zero if LP has a wait status pending. */ - -static int -status_callback (struct lwp_info *lp, void *data) -{ - /* Only report a pending wait status if we pretend that this has - indeed been resumed. */ - return (lp->status != 0 && lp->resumed); -} - -/* Return non-zero if LP isn't stopped. */ - -static int -running_callback (struct lwp_info *lp, void *data) -{ - return (lp->stopped == 0 || (lp->status != 0 && lp->resumed)); -} - -/* Count the LWP's that have had events. */ - -static int -count_events_callback (struct lwp_info *lp, void *data) -{ - int *count = data; - - gdb_assert (count != NULL); - - /* Count only LWPs that have a SIGTRAP event pending. */ - if (lp->status != 0 - && WIFSTOPPED (lp->status) && WSTOPSIG (lp->status) == SIGTRAP) - (*count)++; - - return 0; -} - -/* Select the LWP (if any) that is currently being single-stepped. */ - -static int -select_singlestep_lwp_callback (struct lwp_info *lp, void *data) -{ - if (lp->step && lp->status != 0) - return 1; - else - return 0; -} - -/* Select the Nth LWP that has had a SIGTRAP event. */ - -static int -select_event_lwp_callback (struct lwp_info *lp, void *data) -{ - int *selector = data; - - gdb_assert (selector != NULL); - - /* Select only LWPs that have a SIGTRAP event pending. */ - if (lp->status != 0 - && WIFSTOPPED (lp->status) && WSTOPSIG (lp->status) == SIGTRAP) - if ((*selector)-- == 0) - return 1; - - return 0; -} - -static int -cancel_breakpoints_callback (struct lwp_info *lp, void *data) -{ - struct lwp_info *event_lp = data; - - /* Leave the LWP that has been elected to receive a SIGTRAP alone. */ - if (lp == event_lp) - return 0; - - /* If a LWP other than the LWP that we're reporting an event for has - hit a GDB breakpoint (as opposed to some random trap signal), - then just arrange for it to hit it again later. We don't keep - the SIGTRAP status and don't forward the SIGTRAP signal to the - LWP. We will handle the current event, eventually we will resume - all LWPs, and this one will get its breakpoint trap again. - - If we do not do this, then we run the risk that the user will - delete or disable the breakpoint, but the LWP will have already - tripped on it. */ - - if (lp->status != 0 - && WIFSTOPPED (lp->status) && WSTOPSIG (lp->status) == SIGTRAP - && breakpoint_inserted_here_p (read_pc_pid (lp->ptid) - - DECR_PC_AFTER_BREAK)) - { - if (debug_lin_lwp) - fprintf_unfiltered (gdb_stdlog, - "CBC: Push back breakpoint for %s\n", - target_pid_to_str (lp->ptid)); - - /* Back up the PC if necessary. */ - if (DECR_PC_AFTER_BREAK) - write_pc_pid (read_pc_pid (lp->ptid) - DECR_PC_AFTER_BREAK, lp->ptid); - - /* Throw away the SIGTRAP. */ - lp->status = 0; - } - - return 0; -} - -/* Select one LWP out of those that have events pending. */ - -static void -select_event_lwp (struct lwp_info **orig_lp, int *status) -{ - int num_events = 0; - int random_selector; - struct lwp_info *event_lp; - - /* Record the wait status for the origional LWP. */ - (*orig_lp)->status = *status; - - /* Give preference to any LWP that is being single-stepped. */ - event_lp = iterate_over_lwps (select_singlestep_lwp_callback, NULL); - if (event_lp != NULL) - { - if (debug_lin_lwp) - fprintf_unfiltered (gdb_stdlog, - "SEL: Select single-step %s\n", - target_pid_to_str (event_lp->ptid)); - } - else - { - /* No single-stepping LWP. Select one at random, out of those - which have had SIGTRAP events. */ - - /* First see how many SIGTRAP events we have. */ - iterate_over_lwps (count_events_callback, &num_events); - - /* Now randomly pick a LWP out of those that have had a SIGTRAP. */ - random_selector = (int) - ((num_events * (double) rand ()) / (RAND_MAX + 1.0)); - - if (debug_lin_lwp && num_events > 1) - fprintf_unfiltered (gdb_stdlog, - "SEL: Found %d SIGTRAP events, selecting #%d\n", - num_events, random_selector); - - event_lp = iterate_over_lwps (select_event_lwp_callback, - &random_selector); - } - - if (event_lp != NULL) - { - /* Switch the event LWP. */ - *orig_lp = event_lp; - *status = event_lp->status; - } - - /* Flush the wait status for the event LWP. */ - (*orig_lp)->status = 0; -} - -/* Return non-zero if LP has been resumed. */ - -static int -resumed_callback (struct lwp_info *lp, void *data) -{ - return lp->resumed; -} - -#ifdef CHILD_WAIT - -/* We need to override child_wait to support attaching to cloned - processes, since a normal wait (as done by the default version) - ignores those processes. */ - -/* Wait for child PTID to do something. Return id of the child, - minus_one_ptid in case of error; store status into *OURSTATUS. */ - -ptid_t -child_wait (ptid_t ptid, struct target_waitstatus *ourstatus) -{ - int save_errno; - int status; - pid_t pid; - - ourstatus->kind = TARGET_WAITKIND_IGNORE; - - do - { - set_sigint_trap (); /* Causes SIGINT to be passed on to the - attached process. */ - set_sigio_trap (); - - pid = waitpid (GET_PID (ptid), &status, 0); - if (pid == -1 && errno == ECHILD) - /* Try again with __WCLONE to check cloned processes. */ - pid = waitpid (GET_PID (ptid), &status, __WCLONE); - - if (debug_lin_lwp) - { - fprintf_unfiltered (gdb_stdlog, - "CW: waitpid %ld received %s\n", - (long) pid, status_to_str (status)); - } - - save_errno = errno; - - /* Make sure we don't report an event for the exit of the - original program, if we've detached from it. */ - if (pid != -1 && !WIFSTOPPED (status) && pid != GET_PID (inferior_ptid)) - { - pid = -1; - save_errno = EINTR; - } - - /* Check for stop events reported by a process we didn't already - know about - in this case, anything other than inferior_ptid. - - If we're expecting to receive stopped processes after fork, - vfork, and clone events, then we'll just add the new one to - our list and go back to waiting for the event to be reported - - the stopped process might be returned from waitpid before - or after the event is. If we want to handle debugging of - CLONE_PTRACE processes we need to do more here, i.e. switch - to multi-threaded mode. */ - if (pid != -1 && WIFSTOPPED (status) && WSTOPSIG (status) == SIGSTOP - && pid != GET_PID (inferior_ptid)) - { - linux_record_stopped_pid (pid); - pid = -1; - save_errno = EINTR; - } - - /* Handle GNU/Linux's extended waitstatus for trace events. */ - if (pid != -1 && WIFSTOPPED (status) && WSTOPSIG (status) == SIGTRAP - && status >> 16 != 0) - { - linux_handle_extended_wait (pid, status, ourstatus); - - /* If we see a clone event, detach the child, and don't - report the event. It would be nice to offer some way to - switch into a non-thread-db based threaded mode at this - point. */ - if (ourstatus->kind == TARGET_WAITKIND_SPURIOUS) - { - ptrace (PTRACE_DETACH, ourstatus->value.related_pid, 0, 0); - ourstatus->kind = TARGET_WAITKIND_IGNORE; - ptrace (PTRACE_CONT, pid, 0, 0); - pid = -1; - save_errno = EINTR; - } - } - - clear_sigio_trap (); - clear_sigint_trap (); - } - while (pid == -1 && save_errno == EINTR); - - if (pid == -1) - { - warning ("Child process unexpectedly missing: %s", - safe_strerror (errno)); - - /* Claim it exited with unknown signal. */ - ourstatus->kind = TARGET_WAITKIND_SIGNALLED; - ourstatus->value.sig = TARGET_SIGNAL_UNKNOWN; - return minus_one_ptid; - } - - if (ourstatus->kind == TARGET_WAITKIND_IGNORE) - store_waitstatus (ourstatus, status); - - return pid_to_ptid (pid); -} - -#endif - -/* Stop an active thread, verify it still exists, then resume it. */ - -static int -stop_and_resume_callback (struct lwp_info *lp, void *data) -{ - struct lwp_info *ptr; - - if (!lp->stopped && !lp->signalled) - { - stop_callback (lp, NULL); - stop_wait_callback (lp, NULL); - /* Resume if the lwp still exists. */ - for (ptr = lwp_list; ptr; ptr = ptr->next) - if (lp == ptr) - { - resume_callback (lp, NULL); - resume_set_callback (lp, NULL); - } - } - return 0; -} - -static ptid_t -lin_lwp_wait (ptid_t ptid, struct target_waitstatus *ourstatus) -{ - struct lwp_info *lp = NULL; - int options = 0; - int status = 0; - pid_t pid = PIDGET (ptid); - sigset_t flush_mask; - - sigemptyset (&flush_mask); - - /* Make sure SIGCHLD is blocked. */ - if (!sigismember (&blocked_mask, SIGCHLD)) - { - sigaddset (&blocked_mask, SIGCHLD); - sigprocmask (SIG_BLOCK, &blocked_mask, NULL); - } - -retry: - - /* Make sure there is at least one LWP that has been resumed, at - least if there are any LWPs at all. */ - gdb_assert (num_lwps == 0 || iterate_over_lwps (resumed_callback, NULL)); - - /* First check if there is a LWP with a wait status pending. */ - if (pid == -1) - { - /* Any LWP that's been resumed will do. */ - lp = iterate_over_lwps (status_callback, NULL); - if (lp) - { - status = lp->status; - lp->status = 0; - - if (debug_lin_lwp && status) - fprintf_unfiltered (gdb_stdlog, - "LLW: Using pending wait status %s for %s.\n", - status_to_str (status), - target_pid_to_str (lp->ptid)); - } - - /* But if we don't fine one, we'll have to wait, and check both - cloned and uncloned processes. We start with the cloned - processes. */ - options = __WCLONE | WNOHANG; - } - else if (is_lwp (ptid)) - { - if (debug_lin_lwp) - fprintf_unfiltered (gdb_stdlog, - "LLW: Waiting for specific LWP %s.\n", - target_pid_to_str (ptid)); - - /* We have a specific LWP to check. */ - lp = find_lwp_pid (ptid); - gdb_assert (lp); - status = lp->status; - lp->status = 0; - - if (debug_lin_lwp && status) - fprintf_unfiltered (gdb_stdlog, - "LLW: Using pending wait status %s for %s.\n", - status_to_str (status), - target_pid_to_str (lp->ptid)); - - /* If we have to wait, take into account whether PID is a cloned - process or not. And we have to convert it to something that - the layer beneath us can understand. */ - options = lp->cloned ? __WCLONE : 0; - pid = GET_LWP (ptid); - } - - if (status && lp->signalled) - { - /* A pending SIGSTOP may interfere with the normal stream of - events. In a typical case where interference is a problem, - we have a SIGSTOP signal pending for LWP A while - single-stepping it, encounter an event in LWP B, and take the - pending SIGSTOP while trying to stop LWP A. After processing - the event in LWP B, LWP A is continued, and we'll never see - the SIGTRAP associated with the last time we were - single-stepping LWP A. */ - - /* Resume the thread. It should halt immediately returning the - pending SIGSTOP. */ - registers_changed (); - child_resume (pid_to_ptid (GET_LWP (lp->ptid)), lp->step, - TARGET_SIGNAL_0); - if (debug_lin_lwp) - fprintf_unfiltered (gdb_stdlog, - "LLW: %s %s, 0, 0 (expect SIGSTOP)\n", - lp->step ? "PTRACE_SINGLESTEP" : "PTRACE_CONT", - target_pid_to_str (lp->ptid)); - lp->stopped = 0; - gdb_assert (lp->resumed); - - /* This should catch the pending SIGSTOP. */ - stop_wait_callback (lp, NULL); - } - - set_sigint_trap (); /* Causes SIGINT to be passed on to the - attached process. */ - set_sigio_trap (); - - while (status == 0) - { - pid_t lwpid; - - lwpid = waitpid (pid, &status, options); - if (lwpid > 0) - { - gdb_assert (pid == -1 || lwpid == pid); - - if (debug_lin_lwp) - { - fprintf_unfiltered (gdb_stdlog, - "LLW: waitpid %ld received %s\n", - (long) lwpid, status_to_str (status)); - } - - lp = find_lwp_pid (pid_to_ptid (lwpid)); - - /* Check for stop events reported by a process we didn't - already know about - anything not already in our LWP - list. - - If we're expecting to receive stopped processes after - fork, vfork, and clone events, then we'll just add the - new one to our list and go back to waiting for the event - to be reported - the stopped process might be returned - from waitpid before or after the event is. */ - if (WIFSTOPPED (status) && !lp) - { - linux_record_stopped_pid (lwpid); - status = 0; - continue; - } - - /* Make sure we don't report an event for the exit of an LWP not in - our list, i.e. not part of the current process. This can happen - if we detach from a program we original forked and then it - exits. */ - if (!WIFSTOPPED (status) && !lp) - { - status = 0; - continue; - } - - /* NOTE drow/2003-06-17: This code seems to be meant for debugging - CLONE_PTRACE processes which do not use the thread library - - otherwise we wouldn't find the new LWP this way. That doesn't - currently work, and the following code is currently unreachable - due to the two blocks above. If it's fixed some day, this code - should be broken out into a function so that we can also pick up - LWPs from the new interface. */ - if (!lp) - { - lp = add_lwp (BUILD_LWP (lwpid, GET_PID (inferior_ptid))); - if (options & __WCLONE) - lp->cloned = 1; - - if (threaded) - { - gdb_assert (WIFSTOPPED (status) - && WSTOPSIG (status) == SIGSTOP); - lp->signalled = 1; - - if (!in_thread_list (inferior_ptid)) - { - inferior_ptid = BUILD_LWP (GET_PID (inferior_ptid), - GET_PID (inferior_ptid)); - add_thread (inferior_ptid); - } - - add_thread (lp->ptid); - printf_unfiltered ("[New %s]\n", - target_pid_to_str (lp->ptid)); - } - } - - /* Handle GNU/Linux's extended waitstatus for trace events. */ - if (WIFSTOPPED (status) && WSTOPSIG (status) == SIGTRAP && status >> 16 != 0) - { - if (debug_lin_lwp) - fprintf_unfiltered (gdb_stdlog, - "LLW: Handling extended status 0x%06x\n", - status); - if (lin_lwp_handle_extended (lp, status)) - { - status = 0; - continue; - } - } - - /* Check if the thread has exited. */ - if ((WIFEXITED (status) || WIFSIGNALED (status)) && num_lwps > 1) - { - if (in_thread_list (lp->ptid)) - { - /* Core GDB cannot deal with us deleting the current - thread. */ - if (!ptid_equal (lp->ptid, inferior_ptid)) - delete_thread (lp->ptid); - printf_unfiltered ("[%s exited]\n", - target_pid_to_str (lp->ptid)); - } - - /* If this is the main thread, we must stop all threads and - verify if they are still alive. This is because in the nptl - thread model, there is no signal issued for exiting LWPs - other than the main thread. We only get the main thread - exit signal once all child threads have already exited. - If we stop all the threads and use the stop_wait_callback - to check if they have exited we can determine whether this - signal should be ignored or whether it means the end of the - debugged application, regardless of which threading model - is being used. */ - if (GET_PID (lp->ptid) == GET_LWP (lp->ptid)) - { - lp->stopped = 1; - iterate_over_lwps (stop_and_resume_callback, NULL); - } - - if (debug_lin_lwp) - fprintf_unfiltered (gdb_stdlog, - "LLW: %s exited.\n", - target_pid_to_str (lp->ptid)); - - delete_lwp (lp->ptid); - - /* If there is at least one more LWP, then the exit signal - was not the end of the debugged application and should be - ignored. */ - if (num_lwps > 0) - { - /* Make sure there is at least one thread running. */ - gdb_assert (iterate_over_lwps (running_callback, NULL)); - - /* Discard the event. */ - status = 0; - continue; - } - } - - /* Check if the current LWP has previously exited. In the nptl - thread model, LWPs other than the main thread do not issue - signals when they exit so we must check whenever the thread - has stopped. A similar check is made in stop_wait_callback(). */ - if (num_lwps > 1 && !lin_lwp_thread_alive (lp->ptid)) - { - if (in_thread_list (lp->ptid)) - { - /* Core GDB cannot deal with us deleting the current - thread. */ - if (!ptid_equal (lp->ptid, inferior_ptid)) - delete_thread (lp->ptid); - printf_unfiltered ("[%s exited]\n", - target_pid_to_str (lp->ptid)); - } - if (debug_lin_lwp) - fprintf_unfiltered (gdb_stdlog, - "LLW: %s exited.\n", - target_pid_to_str (lp->ptid)); - - delete_lwp (lp->ptid); - - /* Make sure there is at least one thread running. */ - gdb_assert (iterate_over_lwps (running_callback, NULL)); - - /* Discard the event. */ - status = 0; - continue; - } - - /* Make sure we don't report a SIGSTOP that we sent - ourselves in an attempt to stop an LWP. */ - if (lp->signalled - && WIFSTOPPED (status) && WSTOPSIG (status) == SIGSTOP) - { - if (debug_lin_lwp) - fprintf_unfiltered (gdb_stdlog, - "LLW: Delayed SIGSTOP caught for %s.\n", - target_pid_to_str (lp->ptid)); - - /* This is a delayed SIGSTOP. */ - lp->signalled = 0; - - registers_changed (); - child_resume (pid_to_ptid (GET_LWP (lp->ptid)), lp->step, - TARGET_SIGNAL_0); - if (debug_lin_lwp) - fprintf_unfiltered (gdb_stdlog, - "LLW: %s %s, 0, 0 (discard SIGSTOP)\n", - lp->step ? - "PTRACE_SINGLESTEP" : "PTRACE_CONT", - target_pid_to_str (lp->ptid)); - - lp->stopped = 0; - gdb_assert (lp->resumed); - - /* Discard the event. */ - status = 0; - continue; - } - - break; - } - - if (pid == -1) - { - /* Alternate between checking cloned and uncloned processes. */ - options ^= __WCLONE; - - /* And suspend every time we have checked both. */ - if (options & __WCLONE) - sigsuspend (&suspend_mask); - } - - /* We shouldn't end up here unless we want to try again. */ - gdb_assert (status == 0); - } - - clear_sigio_trap (); - clear_sigint_trap (); - - gdb_assert (lp); - - /* Don't report signals that GDB isn't interested in, such as - signals that are neither printed nor stopped upon. Stopping all - threads can be a bit time-consuming so if we want decent - performance with heavily multi-threaded programs, especially when - they're using a high frequency timer, we'd better avoid it if we - can. */ - - if (WIFSTOPPED (status)) - { - int signo = target_signal_from_host (WSTOPSIG (status)); - - if (signal_stop_state (signo) == 0 - && signal_print_state (signo) == 0 - && signal_pass_state (signo) == 1) - { - /* FIMXE: kettenis/2001-06-06: Should we resume all threads - here? It is not clear we should. GDB may not expect - other threads to run. On the other hand, not resuming - newly attached threads may cause an unwanted delay in - getting them running. */ - registers_changed (); - child_resume (pid_to_ptid (GET_LWP (lp->ptid)), lp->step, signo); - if (debug_lin_lwp) - fprintf_unfiltered (gdb_stdlog, - "LLW: %s %s, %s (preempt 'handle')\n", - lp->step ? - "PTRACE_SINGLESTEP" : "PTRACE_CONT", - target_pid_to_str (lp->ptid), - signo ? strsignal (signo) : "0"); - lp->stopped = 0; - status = 0; - goto retry; - } - - if (signo == TARGET_SIGNAL_INT && signal_pass_state (signo) == 0) - { - /* If ^C/BREAK is typed at the tty/console, SIGINT gets - forwarded to the entire process group, that is, all LWP's - will receive it. Since we only want to report it once, - we try to flush it from all LWPs except this one. */ - sigaddset (&flush_mask, SIGINT); - } - } - - /* This LWP is stopped now. */ - lp->stopped = 1; - - if (debug_lin_lwp) - fprintf_unfiltered (gdb_stdlog, "LLW: Candidate event %s in %s.\n", - status_to_str (status), target_pid_to_str (lp->ptid)); - - /* Now stop all other LWP's ... */ - iterate_over_lwps (stop_callback, NULL); - - /* ... and wait until all of them have reported back that they're no - longer running. */ - iterate_over_lwps (stop_wait_callback, &flush_mask); - iterate_over_lwps (flush_callback, &flush_mask); - - /* If we're not waiting for a specific LWP, choose an event LWP from - among those that have had events. Giving equal priority to all - LWPs that have had events helps prevent starvation. */ - if (pid == -1) - select_event_lwp (&lp, &status); - - /* Now that we've selected our final event LWP, cancel any - breakpoints in other LWPs that have hit a GDB breakpoint. See - the comment in cancel_breakpoints_callback to find out why. */ - iterate_over_lwps (cancel_breakpoints_callback, lp); - - /* If we're not running in "threaded" mode, we'll report the bare - process id. */ - - if (WIFSTOPPED (status) && WSTOPSIG (status) == SIGTRAP) - { - trap_ptid = (threaded ? lp->ptid : pid_to_ptid (GET_LWP (lp->ptid))); - if (debug_lin_lwp) - fprintf_unfiltered (gdb_stdlog, - "LLW: trap_ptid is %s.\n", - target_pid_to_str (trap_ptid)); - } - else - trap_ptid = null_ptid; - - if (lp->waitstatus.kind != TARGET_WAITKIND_IGNORE) - { - *ourstatus = lp->waitstatus; - lp->waitstatus.kind = TARGET_WAITKIND_IGNORE; - } - else - store_waitstatus (ourstatus, status); - - return (threaded ? lp->ptid : pid_to_ptid (GET_LWP (lp->ptid))); -} - -static int -kill_callback (struct lwp_info *lp, void *data) -{ - errno = 0; - ptrace (PTRACE_KILL, GET_LWP (lp->ptid), 0, 0); - if (debug_lin_lwp) - fprintf_unfiltered (gdb_stdlog, - "KC: PTRACE_KILL %s, 0, 0 (%s)\n", - target_pid_to_str (lp->ptid), - errno ? safe_strerror (errno) : "OK"); - - return 0; -} - -static int -kill_wait_callback (struct lwp_info *lp, void *data) -{ - pid_t pid; - - /* We must make sure that there are no pending events (delayed - SIGSTOPs, pending SIGTRAPs, etc.) to make sure the current - program doesn't interfere with any following debugging session. */ - - /* For cloned processes we must check both with __WCLONE and - without, since the exit status of a cloned process isn't reported - with __WCLONE. */ - if (lp->cloned) - { - do - { - pid = waitpid (GET_LWP (lp->ptid), NULL, __WCLONE); - if (pid != (pid_t) -1 && debug_lin_lwp) - { - fprintf_unfiltered (gdb_stdlog, - "KWC: wait %s received unknown.\n", - target_pid_to_str (lp->ptid)); - } - } - while (pid == GET_LWP (lp->ptid)); - - gdb_assert (pid == -1 && errno == ECHILD); - } - - do - { - pid = waitpid (GET_LWP (lp->ptid), NULL, 0); - if (pid != (pid_t) -1 && debug_lin_lwp) - { - fprintf_unfiltered (gdb_stdlog, - "KWC: wait %s received unk.\n", - target_pid_to_str (lp->ptid)); - } - } - while (pid == GET_LWP (lp->ptid)); - - gdb_assert (pid == -1 && errno == ECHILD); - return 0; -} - -static void -lin_lwp_kill (void) -{ - /* Kill all LWP's ... */ - iterate_over_lwps (kill_callback, NULL); - - /* ... and wait until we've flushed all events. */ - iterate_over_lwps (kill_wait_callback, NULL); - - target_mourn_inferior (); -} - -static void -lin_lwp_create_inferior (char *exec_file, char *allargs, char **env, - int from_tty) -{ - child_ops.to_create_inferior (exec_file, allargs, env, from_tty); -} - -static void -lin_lwp_mourn_inferior (void) -{ - trap_ptid = null_ptid; - - /* Destroy LWP info; it's no longer valid. */ - init_lwp_list (); - - /* Restore the original signal mask. */ - sigprocmask (SIG_SETMASK, &normal_mask, NULL); - sigemptyset (&blocked_mask); - - child_ops.to_mourn_inferior (); -} - -static int -lin_lwp_xfer_memory (CORE_ADDR memaddr, char *myaddr, int len, int write, - struct mem_attrib *attrib, struct target_ops *target) -{ - struct cleanup *old_chain = save_inferior_ptid (); - int xfer; - - if (is_lwp (inferior_ptid)) - inferior_ptid = pid_to_ptid (GET_LWP (inferior_ptid)); - - xfer = linux_proc_xfer_memory (memaddr, myaddr, len, write, attrib, target); - if (xfer == 0) - xfer = child_xfer_memory (memaddr, myaddr, len, write, attrib, target); - - do_cleanups (old_chain); - return xfer; -} - -static int -lin_lwp_thread_alive (ptid_t ptid) -{ - gdb_assert (is_lwp (ptid)); - - errno = 0; - ptrace (PTRACE_PEEKUSER, GET_LWP (ptid), 0, 0); - if (debug_lin_lwp) - fprintf_unfiltered (gdb_stdlog, - "LLTA: PTRACE_PEEKUSER %s, 0, 0 (%s)\n", - target_pid_to_str (ptid), - errno ? safe_strerror (errno) : "OK"); - if (errno) - return 0; - - return 1; -} - -static char * -lin_lwp_pid_to_str (ptid_t ptid) -{ - static char buf[64]; - - if (is_lwp (ptid)) - { - snprintf (buf, sizeof (buf), "LWP %ld", GET_LWP (ptid)); - return buf; - } - - return normal_pid_to_str (ptid); -} - -static void -init_lin_lwp_ops (void) -{ -#if 0 - lin_lwp_ops.to_open = lin_lwp_open; -#endif - lin_lwp_ops.to_shortname = "lwp-layer"; - lin_lwp_ops.to_longname = "lwp-layer"; - lin_lwp_ops.to_doc = "Low level threads support (LWP layer)"; - lin_lwp_ops.to_attach = lin_lwp_attach; - lin_lwp_ops.to_detach = lin_lwp_detach; - lin_lwp_ops.to_resume = lin_lwp_resume; - lin_lwp_ops.to_wait = lin_lwp_wait; - /* fetch_inferior_registers and store_inferior_registers will - honor the LWP id, so we can use them directly. */ - lin_lwp_ops.to_fetch_registers = fetch_inferior_registers; - lin_lwp_ops.to_store_registers = store_inferior_registers; - lin_lwp_ops.to_xfer_memory = lin_lwp_xfer_memory; - lin_lwp_ops.to_kill = lin_lwp_kill; - lin_lwp_ops.to_create_inferior = lin_lwp_create_inferior; - lin_lwp_ops.to_mourn_inferior = lin_lwp_mourn_inferior; - lin_lwp_ops.to_thread_alive = lin_lwp_thread_alive; - lin_lwp_ops.to_pid_to_str = lin_lwp_pid_to_str; - lin_lwp_ops.to_post_startup_inferior = child_post_startup_inferior; - lin_lwp_ops.to_post_attach = child_post_attach; - lin_lwp_ops.to_insert_fork_catchpoint = child_insert_fork_catchpoint; - lin_lwp_ops.to_insert_vfork_catchpoint = child_insert_vfork_catchpoint; - lin_lwp_ops.to_insert_exec_catchpoint = child_insert_exec_catchpoint; - - lin_lwp_ops.to_stratum = thread_stratum; - lin_lwp_ops.to_has_thread_control = tc_schedlock; - lin_lwp_ops.to_magic = OPS_MAGIC; -} - -static void -sigchld_handler (int signo) -{ - /* Do nothing. The only reason for this handler is that it allows - us to use sigsuspend in lin_lwp_wait above to wait for the - arrival of a SIGCHLD. */ -} - -void -_initialize_lin_lwp (void) -{ - struct sigaction action; - - extern void thread_db_init (struct target_ops *); - - init_lin_lwp_ops (); - add_target (&lin_lwp_ops); - thread_db_init (&lin_lwp_ops); - - /* Save the original signal mask. */ - sigprocmask (SIG_SETMASK, NULL, &normal_mask); - - action.sa_handler = sigchld_handler; - sigemptyset (&action.sa_mask); - action.sa_flags = 0; - sigaction (SIGCHLD, &action, NULL); - - /* Make sure we don't block SIGCHLD during a sigsuspend. */ - sigprocmask (SIG_SETMASK, NULL, &suspend_mask); - sigdelset (&suspend_mask, SIGCHLD); - - sigemptyset (&blocked_mask); - - deprecated_add_show_from_set - (add_set_cmd ("lin-lwp", no_class, var_zinteger, - (char *) &debug_lin_lwp, - "Set debugging of GNU/Linux lwp module.\n\ -Enables printf debugging output.\n", &setdebuglist), &showdebuglist); -} - - -/* FIXME: kettenis/2000-08-26: The stuff on this page is specific to - the GNU/Linux Threads library and therefore doesn't really belong - here. */ - -/* Read variable NAME in the target and return its value if found. - Otherwise return zero. It is assumed that the type of the variable - is `int'. */ - -static int -get_signo (const char *name) -{ - struct minimal_symbol *ms; - int signo; - - ms = lookup_minimal_symbol (name, NULL, NULL); - if (ms == NULL) - return 0; - - if (target_read_memory (SYMBOL_VALUE_ADDRESS (ms), (char *) &signo, - sizeof (signo)) != 0) - return 0; - - return signo; -} - -/* Return the set of signals used by the threads library in *SET. */ - -void -lin_thread_get_thread_signals (sigset_t *set) -{ - struct sigaction action; - int restart, cancel; - - sigemptyset (set); - - restart = get_signo ("__pthread_sig_restart"); - if (restart == 0) - return; - - cancel = get_signo ("__pthread_sig_cancel"); - if (cancel == 0) - return; - - sigaddset (set, restart); - sigaddset (set, cancel); - - /* The GNU/Linux Threads library makes terminating threads send a - special "cancel" signal instead of SIGCHLD. Make sure we catch - those (to prevent them from terminating GDB itself, which is - likely to be their default action) and treat them the same way as - SIGCHLD. */ - - action.sa_handler = sigchld_handler; - sigemptyset (&action.sa_mask); - action.sa_flags = 0; - sigaction (cancel, &action, NULL); - - /* We block the "cancel" signal throughout this code ... */ - sigaddset (&blocked_mask, cancel); - sigprocmask (SIG_BLOCK, &blocked_mask, NULL); - - /* ... except during a sigsuspend. */ - sigdelset (&suspend_mask, cancel); -} diff --git a/gdb/linux-nat.c b/gdb/linux-nat.c index 15b6704..6207e4d 100644 --- a/gdb/linux-nat.c +++ b/gdb/linux-nat.c @@ -21,11 +21,18 @@ #include "defs.h" #include "inferior.h" #include "target.h" - +#include "gdb_string.h" #include "gdb_wait.h" +#include "gdb_assert.h" +#ifdef HAVE_TKILL_SYSCALL +#include <unistd.h> +#include <sys/syscall.h> +#endif #include <sys/ptrace.h> - #include "linux-nat.h" +#include "gdbthread.h" +#include "gdbcmd.h" +#include "regcache.h" /* If the system headers did not provide the constants, hard-code the normal values. */ @@ -60,6 +67,8 @@ #define __WALL 0x40000000 /* Wait for any child. */ #endif +static int debug_linux_nat; + extern struct target_ops child_ops; static int linux_parent_pid; @@ -519,3 +528,1920 @@ kill_inferior (void) target_mourn_inferior (); } + +/* On GNU/Linux there are no real LWP's. The closest thing to LWP's + are processes sharing the same VM space. A multi-threaded process + is basically a group of such processes. However, such a grouping + is almost entirely a user-space issue; the kernel doesn't enforce + such a grouping at all (this might change in the future). In + general, we'll rely on the threads library (i.e. the GNU/Linux + Threads library) to provide such a grouping. + + It is perfectly well possible to write a multi-threaded application + without the assistance of a threads library, by using the clone + system call directly. This module should be able to give some + rudimentary support for debugging such applications if developers + specify the CLONE_PTRACE flag in the clone system call, and are + using the Linux kernel 2.4 or above. + + Note that there are some peculiarities in GNU/Linux that affect + this code: + + - In general one should specify the __WCLONE flag to waitpid in + order to make it report events for any of the cloned processes + (and leave it out for the initial process). However, if a cloned + process has exited the exit status is only reported if the + __WCLONE flag is absent. Linux kernel 2.4 has a __WALL flag, but + we cannot use it since GDB must work on older systems too. + + - When a traced, cloned process exits and is waited for by the + debugger, the kernel reassigns it to the original parent and + keeps it around as a "zombie". Somehow, the GNU/Linux Threads + library doesn't notice this, which leads to the "zombie problem": + When debugged a multi-threaded process that spawns a lot of + threads will run out of processes, even if the threads exit, + because the "zombies" stay around. */ + +/* List of known LWPs. */ +static struct lwp_info *lwp_list; + +/* Number of LWPs in the list. */ +static int num_lwps; + +/* Non-zero if we're running in "threaded" mode. */ +static int threaded; + + +#define GET_LWP(ptid) ptid_get_lwp (ptid) +#define GET_PID(ptid) ptid_get_pid (ptid) +#define is_lwp(ptid) (GET_LWP (ptid) != 0) +#define BUILD_LWP(lwp, pid) ptid_build (pid, lwp, 0) + +/* If the last reported event was a SIGTRAP, this variable is set to + the process id of the LWP/thread that got it. */ +ptid_t trap_ptid; + + +/* This module's target-specific operations. */ +static struct target_ops linux_nat_ops; + +/* The standard child operations. */ +extern struct target_ops child_ops; + +/* Since we cannot wait (in linux_nat_wait) for the initial process and + any cloned processes with a single call to waitpid, we have to use + the WNOHANG flag and call waitpid in a loop. To optimize + things a bit we use `sigsuspend' to wake us up when a process has + something to report (it will send us a SIGCHLD if it has). To make + this work we have to juggle with the signal mask. We save the + original signal mask such that we can restore it before creating a + new process in order to avoid blocking certain signals in the + inferior. We then block SIGCHLD during the waitpid/sigsuspend + loop. */ + +/* Original signal mask. */ +static sigset_t normal_mask; + +/* Signal mask for use with sigsuspend in linux_nat_wait, initialized in + _initialize_linux_nat. */ +static sigset_t suspend_mask; + +/* Signals to block to make that sigsuspend work. */ +static sigset_t blocked_mask; + + +/* Prototypes for local functions. */ +static int stop_wait_callback (struct lwp_info *lp, void *data); +static int linux_nat_thread_alive (ptid_t ptid); + +/* Convert wait status STATUS to a string. Used for printing debug + messages only. */ + +static char * +status_to_str (int status) +{ + static char buf[64]; + + if (WIFSTOPPED (status)) + snprintf (buf, sizeof (buf), "%s (stopped)", + strsignal (WSTOPSIG (status))); + else if (WIFSIGNALED (status)) + snprintf (buf, sizeof (buf), "%s (terminated)", + strsignal (WSTOPSIG (status))); + else + snprintf (buf, sizeof (buf), "%d (exited)", WEXITSTATUS (status)); + + return buf; +} + +/* Initialize the list of LWPs. Note that this module, contrary to + what GDB's generic threads layer does for its thread list, + re-initializes the LWP lists whenever we mourn or detach (which + doesn't involve mourning) the inferior. */ + +static void +init_lwp_list (void) +{ + struct lwp_info *lp, *lpnext; + + for (lp = lwp_list; lp; lp = lpnext) + { + lpnext = lp->next; + xfree (lp); + } + + lwp_list = NULL; + num_lwps = 0; + threaded = 0; +} + +/* Add the LWP specified by PID to the list. If this causes the + number of LWPs to become larger than one, go into "threaded" mode. + Return a pointer to the structure describing the new LWP. */ + +static struct lwp_info * +add_lwp (ptid_t ptid) +{ + struct lwp_info *lp; + + gdb_assert (is_lwp (ptid)); + + lp = (struct lwp_info *) xmalloc (sizeof (struct lwp_info)); + + memset (lp, 0, sizeof (struct lwp_info)); + + lp->waitstatus.kind = TARGET_WAITKIND_IGNORE; + + lp->ptid = ptid; + + lp->next = lwp_list; + lwp_list = lp; + if (++num_lwps > 1) + threaded = 1; + + return lp; +} + +/* Remove the LWP specified by PID from the list. */ + +static void +delete_lwp (ptid_t ptid) +{ + struct lwp_info *lp, *lpprev; + + lpprev = NULL; + + for (lp = lwp_list; lp; lpprev = lp, lp = lp->next) + if (ptid_equal (lp->ptid, ptid)) + break; + + if (!lp) + return; + + /* We don't go back to "non-threaded" mode if the number of threads + becomes less than two. */ + num_lwps--; + + if (lpprev) + lpprev->next = lp->next; + else + lwp_list = lp->next; + + xfree (lp); +} + +/* Return a pointer to the structure describing the LWP corresponding + to PID. If no corresponding LWP could be found, return NULL. */ + +static struct lwp_info * +find_lwp_pid (ptid_t ptid) +{ + struct lwp_info *lp; + int lwp; + + if (is_lwp (ptid)) + lwp = GET_LWP (ptid); + else + lwp = GET_PID (ptid); + + for (lp = lwp_list; lp; lp = lp->next) + if (lwp == GET_LWP (lp->ptid)) + return lp; + + return NULL; +} + +/* Call CALLBACK with its second argument set to DATA for every LWP in + the list. If CALLBACK returns 1 for a particular LWP, return a + pointer to the structure describing that LWP immediately. + Otherwise return NULL. */ + +struct lwp_info * +iterate_over_lwps (int (*callback) (struct lwp_info *, void *), void *data) +{ + struct lwp_info *lp, *lpnext; + + for (lp = lwp_list; lp; lp = lpnext) + { + lpnext = lp->next; + if ((*callback) (lp, data)) + return lp; + } + + return NULL; +} + +/* Attach to the LWP specified by PID. If VERBOSE is non-zero, print + a message telling the user that a new LWP has been added to the + process. */ + +void +lin_lwp_attach_lwp (ptid_t ptid, int verbose) +{ + struct lwp_info *lp, *found_lp; + + gdb_assert (is_lwp (ptid)); + + /* Make sure SIGCHLD is blocked. We don't want SIGCHLD events + to interrupt either the ptrace() or waitpid() calls below. */ + if (!sigismember (&blocked_mask, SIGCHLD)) + { + sigaddset (&blocked_mask, SIGCHLD); + sigprocmask (SIG_BLOCK, &blocked_mask, NULL); + } + + if (verbose) + printf_filtered ("[New %s]\n", target_pid_to_str (ptid)); + + found_lp = lp = find_lwp_pid (ptid); + if (lp == NULL) + lp = add_lwp (ptid); + + /* We assume that we're already attached to any LWP that has an id + equal to the overall process id, and to any LWP that is already + in our list of LWPs. If we're not seeing exit events from threads + and we've had PID wraparound since we last tried to stop all threads, + this assumption might be wrong; fortunately, this is very unlikely + to happen. */ + if (GET_LWP (ptid) != GET_PID (ptid) && found_lp == NULL) + { + pid_t pid; + int status; + + if (ptrace (PTRACE_ATTACH, GET_LWP (ptid), 0, 0) < 0) + error ("Can't attach %s: %s", target_pid_to_str (ptid), + safe_strerror (errno)); + + if (debug_linux_nat) + fprintf_unfiltered (gdb_stdlog, + "LLAL: PTRACE_ATTACH %s, 0, 0 (OK)\n", + target_pid_to_str (ptid)); + + pid = waitpid (GET_LWP (ptid), &status, 0); + if (pid == -1 && errno == ECHILD) + { + /* Try again with __WCLONE to check cloned processes. */ + pid = waitpid (GET_LWP (ptid), &status, __WCLONE); + lp->cloned = 1; + } + + gdb_assert (pid == GET_LWP (ptid) + && WIFSTOPPED (status) && WSTOPSIG (status)); + + child_post_attach (pid); + + lp->stopped = 1; + + if (debug_linux_nat) + { + fprintf_unfiltered (gdb_stdlog, + "LLAL: waitpid %s received %s\n", + target_pid_to_str (ptid), + status_to_str (status)); + } + } + else + { + /* We assume that the LWP representing the original process is + already stopped. Mark it as stopped in the data structure + that the linux ptrace layer uses to keep track of threads. + Note that this won't have already been done since the main + thread will have, we assume, been stopped by an attach from a + different layer. */ + lp->stopped = 1; + } +} + +static void +linux_nat_attach (char *args, int from_tty) +{ + struct lwp_info *lp; + pid_t pid; + int status; + + /* FIXME: We should probably accept a list of process id's, and + attach all of them. */ + child_ops.to_attach (args, from_tty); + + /* Add the initial process as the first LWP to the list. */ + lp = add_lwp (BUILD_LWP (GET_PID (inferior_ptid), GET_PID (inferior_ptid))); + + /* Make sure the initial process is stopped. The user-level threads + layer might want to poke around in the inferior, and that won't + work if things haven't stabilized yet. */ + pid = waitpid (GET_PID (inferior_ptid), &status, 0); + if (pid == -1 && errno == ECHILD) + { + warning ("%s is a cloned process", target_pid_to_str (inferior_ptid)); + + /* Try again with __WCLONE to check cloned processes. */ + pid = waitpid (GET_PID (inferior_ptid), &status, __WCLONE); + lp->cloned = 1; + } + + gdb_assert (pid == GET_PID (inferior_ptid) + && WIFSTOPPED (status) && WSTOPSIG (status) == SIGSTOP); + + lp->stopped = 1; + + /* Fake the SIGSTOP that core GDB expects. */ + lp->status = W_STOPCODE (SIGSTOP); + lp->resumed = 1; + if (debug_linux_nat) + { + fprintf_unfiltered (gdb_stdlog, + "LLA: waitpid %ld, faking SIGSTOP\n", (long) pid); + } +} + +static int +detach_callback (struct lwp_info *lp, void *data) +{ + gdb_assert (lp->status == 0 || WIFSTOPPED (lp->status)); + + if (debug_linux_nat && lp->status) + fprintf_unfiltered (gdb_stdlog, "DC: Pending %s for %s on detach.\n", + strsignal (WSTOPSIG (lp->status)), + target_pid_to_str (lp->ptid)); + + while (lp->signalled && lp->stopped) + { + errno = 0; + if (ptrace (PTRACE_CONT, GET_LWP (lp->ptid), 0, + WSTOPSIG (lp->status)) < 0) + error ("Can't continue %s: %s", target_pid_to_str (lp->ptid), + safe_strerror (errno)); + + if (debug_linux_nat) + fprintf_unfiltered (gdb_stdlog, + "DC: PTRACE_CONTINUE (%s, 0, %s) (OK)\n", + target_pid_to_str (lp->ptid), + status_to_str (lp->status)); + + lp->stopped = 0; + lp->signalled = 0; + lp->status = 0; + /* FIXME drow/2003-08-26: There was a call to stop_wait_callback + here. But since lp->signalled was cleared above, + stop_wait_callback didn't do anything; the process was left + running. Shouldn't we be waiting for it to stop? + I've removed the call, since stop_wait_callback now does do + something when called with lp->signalled == 0. */ + + gdb_assert (lp->status == 0 || WIFSTOPPED (lp->status)); + } + + /* We don't actually detach from the LWP that has an id equal to the + overall process id just yet. */ + if (GET_LWP (lp->ptid) != GET_PID (lp->ptid)) + { + errno = 0; + if (ptrace (PTRACE_DETACH, GET_LWP (lp->ptid), 0, + WSTOPSIG (lp->status)) < 0) + error ("Can't detach %s: %s", target_pid_to_str (lp->ptid), + safe_strerror (errno)); + + if (debug_linux_nat) + fprintf_unfiltered (gdb_stdlog, + "PTRACE_DETACH (%s, %s, 0) (OK)\n", + target_pid_to_str (lp->ptid), + strsignal (WSTOPSIG (lp->status))); + + delete_lwp (lp->ptid); + } + + return 0; +} + +static void +linux_nat_detach (char *args, int from_tty) +{ + iterate_over_lwps (detach_callback, NULL); + + /* Only the initial process should be left right now. */ + gdb_assert (num_lwps == 1); + + trap_ptid = null_ptid; + + /* Destroy LWP info; it's no longer valid. */ + init_lwp_list (); + + /* Restore the original signal mask. */ + sigprocmask (SIG_SETMASK, &normal_mask, NULL); + sigemptyset (&blocked_mask); + + inferior_ptid = pid_to_ptid (GET_PID (inferior_ptid)); + child_ops.to_detach (args, from_tty); +} + +/* Resume LP. */ + +static int +resume_callback (struct lwp_info *lp, void *data) +{ + if (lp->stopped && lp->status == 0) + { + struct thread_info *tp; + + child_resume (pid_to_ptid (GET_LWP (lp->ptid)), 0, TARGET_SIGNAL_0); + if (debug_linux_nat) + fprintf_unfiltered (gdb_stdlog, + "RC: PTRACE_CONT %s, 0, 0 (resume sibling)\n", + target_pid_to_str (lp->ptid)); + lp->stopped = 0; + lp->step = 0; + } + + return 0; +} + +static int +resume_clear_callback (struct lwp_info *lp, void *data) +{ + lp->resumed = 0; + return 0; +} + +static int +resume_set_callback (struct lwp_info *lp, void *data) +{ + lp->resumed = 1; + return 0; +} + +static void +linux_nat_resume (ptid_t ptid, int step, enum target_signal signo) +{ + struct lwp_info *lp; + int resume_all; + + /* A specific PTID means `step only this process id'. */ + resume_all = (PIDGET (ptid) == -1); + + if (resume_all) + iterate_over_lwps (resume_set_callback, NULL); + else + iterate_over_lwps (resume_clear_callback, NULL); + + /* If PID is -1, it's the current inferior that should be + handled specially. */ + if (PIDGET (ptid) == -1) + ptid = inferior_ptid; + + lp = find_lwp_pid (ptid); + if (lp) + { + ptid = pid_to_ptid (GET_LWP (lp->ptid)); + + /* Remember if we're stepping. */ + lp->step = step; + + /* Mark this LWP as resumed. */ + lp->resumed = 1; + + /* If we have a pending wait status for this thread, there is no + point in resuming the process. */ + if (lp->status) + { + /* FIXME: What should we do if we are supposed to continue + this thread with a signal? */ + gdb_assert (signo == TARGET_SIGNAL_0); + return; + } + + /* Mark LWP as not stopped to prevent it from being continued by + resume_callback. */ + lp->stopped = 0; + } + + if (resume_all) + iterate_over_lwps (resume_callback, NULL); + + child_resume (ptid, step, signo); + if (debug_linux_nat) + fprintf_unfiltered (gdb_stdlog, + "LLR: %s %s, %s (resume event thread)\n", + step ? "PTRACE_SINGLESTEP" : "PTRACE_CONT", + target_pid_to_str (ptid), + signo ? strsignal (signo) : "0"); +} + +/* Issue kill to specified lwp. */ + +static int tkill_failed; + +static int +kill_lwp (int lwpid, int signo) +{ + errno = 0; + +/* Use tkill, if possible, in case we are using nptl threads. If tkill + fails, then we are not using nptl threads and we should be using kill. */ + +#ifdef HAVE_TKILL_SYSCALL + if (!tkill_failed) + { + int ret = syscall (__NR_tkill, lwpid, signo); + if (errno != ENOSYS) + return ret; + errno = 0; + tkill_failed = 1; + } +#endif + + return kill (lwpid, signo); +} + +/* Handle a GNU/Linux extended wait response. Most of the work we + just pass off to linux_handle_extended_wait, but if it reports a + clone event we need to add the new LWP to our list (and not report + the trap to higher layers). This function returns non-zero if + the event should be ignored and we should wait again. */ + +static int +linux_nat_handle_extended (struct lwp_info *lp, int status) +{ + linux_handle_extended_wait (GET_LWP (lp->ptid), status, + &lp->waitstatus); + + /* TARGET_WAITKIND_SPURIOUS is used to indicate clone events. */ + if (lp->waitstatus.kind == TARGET_WAITKIND_SPURIOUS) + { + struct lwp_info *new_lp; + new_lp = add_lwp (BUILD_LWP (lp->waitstatus.value.related_pid, + GET_PID (inferior_ptid))); + new_lp->cloned = 1; + new_lp->stopped = 1; + + lp->waitstatus.kind = TARGET_WAITKIND_IGNORE; + + if (debug_linux_nat) + fprintf_unfiltered (gdb_stdlog, + "LLHE: Got clone event from LWP %ld, resuming\n", + GET_LWP (lp->ptid)); + ptrace (PTRACE_CONT, GET_LWP (lp->ptid), 0, 0); + + return 1; + } + + return 0; +} + +/* Wait for LP to stop. Returns the wait status, or 0 if the LWP has + exited. */ + +static int +wait_lwp (struct lwp_info *lp) +{ + pid_t pid; + int status; + int thread_dead = 0; + + gdb_assert (!lp->stopped); + gdb_assert (lp->status == 0); + + pid = waitpid (GET_LWP (lp->ptid), &status, 0); + if (pid == -1 && errno == ECHILD) + { + pid = waitpid (GET_LWP (lp->ptid), &status, __WCLONE); + if (pid == -1 && errno == ECHILD) + { + /* The thread has previously exited. We need to delete it + now because, for some vendor 2.4 kernels with NPTL + support backported, there won't be an exit event unless + it is the main thread. 2.6 kernels will report an exit + event for each thread that exits, as expected. */ + thread_dead = 1; + if (debug_linux_nat) + fprintf_unfiltered (gdb_stdlog, "WL: %s vanished.\n", + target_pid_to_str (lp->ptid)); + } + } + + if (!thread_dead) + { + gdb_assert (pid == GET_LWP (lp->ptid)); + + if (debug_linux_nat) + { + fprintf_unfiltered (gdb_stdlog, + "WL: waitpid %s received %s\n", + target_pid_to_str (lp->ptid), + status_to_str (status)); + } + } + + /* Check if the thread has exited. */ + if (WIFEXITED (status) || WIFSIGNALED (status)) + { + thread_dead = 1; + if (debug_linux_nat) + fprintf_unfiltered (gdb_stdlog, "WL: %s exited.\n", + target_pid_to_str (lp->ptid)); + } + + if (thread_dead) + { + if (in_thread_list (lp->ptid)) + { + /* Core GDB cannot deal with us deleting the current thread. */ + if (!ptid_equal (lp->ptid, inferior_ptid)) + delete_thread (lp->ptid); + printf_unfiltered ("[%s exited]\n", + target_pid_to_str (lp->ptid)); + } + + delete_lwp (lp->ptid); + return 0; + } + + gdb_assert (WIFSTOPPED (status)); + + /* Handle GNU/Linux's extended waitstatus for trace events. */ + if (WIFSTOPPED (status) && WSTOPSIG (status) == SIGTRAP && status >> 16 != 0) + { + if (debug_linux_nat) + fprintf_unfiltered (gdb_stdlog, + "WL: Handling extended status 0x%06x\n", + status); + if (linux_nat_handle_extended (lp, status)) + return wait_lwp (lp); + } + + return status; +} + +/* Send a SIGSTOP to LP. */ + +static int +stop_callback (struct lwp_info *lp, void *data) +{ + if (!lp->stopped && !lp->signalled) + { + int ret; + + if (debug_linux_nat) + { + fprintf_unfiltered (gdb_stdlog, + "SC: kill %s **<SIGSTOP>**\n", + target_pid_to_str (lp->ptid)); + } + errno = 0; + ret = kill_lwp (GET_LWP (lp->ptid), SIGSTOP); + if (debug_linux_nat) + { + fprintf_unfiltered (gdb_stdlog, + "SC: lwp kill %d %s\n", + ret, + errno ? safe_strerror (errno) : "ERRNO-OK"); + } + + lp->signalled = 1; + gdb_assert (lp->status == 0); + } + + return 0; +} + +/* Wait until LP is stopped. If DATA is non-null it is interpreted as + a pointer to a set of signals to be flushed immediately. */ + +static int +stop_wait_callback (struct lwp_info *lp, void *data) +{ + sigset_t *flush_mask = data; + + if (!lp->stopped) + { + int status; + + status = wait_lwp (lp); + if (status == 0) + return 0; + + /* Ignore any signals in FLUSH_MASK. */ + if (flush_mask && sigismember (flush_mask, WSTOPSIG (status))) + { + if (!lp->signalled) + { + lp->stopped = 1; + return 0; + } + + errno = 0; + ptrace (PTRACE_CONT, GET_LWP (lp->ptid), 0, 0); + if (debug_linux_nat) + fprintf_unfiltered (gdb_stdlog, + "PTRACE_CONT %s, 0, 0 (%s)\n", + target_pid_to_str (lp->ptid), + errno ? safe_strerror (errno) : "OK"); + + return stop_wait_callback (lp, flush_mask); + } + + if (WSTOPSIG (status) != SIGSTOP) + { + if (WSTOPSIG (status) == SIGTRAP) + { + /* If a LWP other than the LWP that we're reporting an + event for has hit a GDB breakpoint (as opposed to + some random trap signal), then just arrange for it to + hit it again later. We don't keep the SIGTRAP status + and don't forward the SIGTRAP signal to the LWP. We + will handle the current event, eventually we will + resume all LWPs, and this one will get its breakpoint + trap again. + + If we do not do this, then we run the risk that the + user will delete or disable the breakpoint, but the + thread will have already tripped on it. */ + + /* Now resume this LWP and get the SIGSTOP event. */ + errno = 0; + ptrace (PTRACE_CONT, GET_LWP (lp->ptid), 0, 0); + if (debug_linux_nat) + { + fprintf_unfiltered (gdb_stdlog, + "PTRACE_CONT %s, 0, 0 (%s)\n", + target_pid_to_str (lp->ptid), + errno ? safe_strerror (errno) : "OK"); + + fprintf_unfiltered (gdb_stdlog, + "SWC: Candidate SIGTRAP event in %s\n", + target_pid_to_str (lp->ptid)); + } + /* Hold the SIGTRAP for handling by linux_nat_wait. */ + stop_wait_callback (lp, data); + /* If there's another event, throw it back into the queue. */ + if (lp->status) + { + if (debug_linux_nat) + { + fprintf_unfiltered (gdb_stdlog, + "SWC: kill %s, %s\n", + target_pid_to_str (lp->ptid), + status_to_str ((int) status)); + } + kill_lwp (GET_LWP (lp->ptid), WSTOPSIG (lp->status)); + } + /* Save the sigtrap event. */ + lp->status = status; + return 0; + } + else + { + /* The thread was stopped with a signal other than + SIGSTOP, and didn't accidentally trip a breakpoint. */ + + if (debug_linux_nat) + { + fprintf_unfiltered (gdb_stdlog, + "SWC: Pending event %s in %s\n", + status_to_str ((int) status), + target_pid_to_str (lp->ptid)); + } + /* Now resume this LWP and get the SIGSTOP event. */ + errno = 0; + ptrace (PTRACE_CONT, GET_LWP (lp->ptid), 0, 0); + if (debug_linux_nat) + fprintf_unfiltered (gdb_stdlog, + "SWC: PTRACE_CONT %s, 0, 0 (%s)\n", + target_pid_to_str (lp->ptid), + errno ? safe_strerror (errno) : "OK"); + + /* Hold this event/waitstatus while we check to see if + there are any more (we still want to get that SIGSTOP). */ + stop_wait_callback (lp, data); + /* If the lp->status field is still empty, use it to hold + this event. If not, then this event must be returned + to the event queue of the LWP. */ + if (lp->status == 0) + lp->status = status; + else + { + if (debug_linux_nat) + { + fprintf_unfiltered (gdb_stdlog, + "SWC: kill %s, %s\n", + target_pid_to_str (lp->ptid), + status_to_str ((int) status)); + } + kill_lwp (GET_LWP (lp->ptid), WSTOPSIG (status)); + } + return 0; + } + } + else + { + /* We caught the SIGSTOP that we intended to catch, so + there's no SIGSTOP pending. */ + lp->stopped = 1; + lp->signalled = 0; + } + } + + return 0; +} + +/* Check whether PID has any pending signals in FLUSH_MASK. If so set + the appropriate bits in PENDING, and return 1 - otherwise return 0. */ + +static int +linux_nat_has_pending (int pid, sigset_t *pending, sigset_t *flush_mask) +{ + sigset_t blocked, ignored; + int i; + + linux_proc_pending_signals (pid, pending, &blocked, &ignored); + + if (!flush_mask) + return 0; + + for (i = 1; i < NSIG; i++) + if (sigismember (pending, i)) + if (!sigismember (flush_mask, i) + || sigismember (&blocked, i) + || sigismember (&ignored, i)) + sigdelset (pending, i); + + if (sigisemptyset (pending)) + return 0; + + return 1; +} + +/* DATA is interpreted as a mask of signals to flush. If LP has + signals pending, and they are all in the flush mask, then arrange + to flush them. LP should be stopped, as should all other threads + it might share a signal queue with. */ + +static int +flush_callback (struct lwp_info *lp, void *data) +{ + sigset_t *flush_mask = data; + sigset_t pending, intersection, blocked, ignored; + int pid, status; + + /* Normally, when an LWP exits, it is removed from the LWP list. The + last LWP isn't removed till later, however. So if there is only + one LWP on the list, make sure it's alive. */ + if (lwp_list == lp && lp->next == NULL) + if (!linux_nat_thread_alive (lp->ptid)) + return 0; + + /* Just because the LWP is stopped doesn't mean that new signals + can't arrive from outside, so this function must be careful of + race conditions. However, because all threads are stopped, we + can assume that the pending mask will not shrink unless we resume + the LWP, and that it will then get another signal. We can't + control which one, however. */ + + if (lp->status) + { + if (debug_linux_nat) + printf_unfiltered ("FC: LP has pending status %06x\n", lp->status); + if (WIFSTOPPED (lp->status) && sigismember (flush_mask, WSTOPSIG (lp->status))) + lp->status = 0; + } + + while (linux_nat_has_pending (GET_LWP (lp->ptid), &pending, flush_mask)) + { + int ret; + + errno = 0; + ret = ptrace (PTRACE_CONT, GET_LWP (lp->ptid), 0, 0); + if (debug_linux_nat) + fprintf_unfiltered (gdb_stderr, + "FC: Sent PTRACE_CONT, ret %d %d\n", ret, errno); + + lp->stopped = 0; + stop_wait_callback (lp, flush_mask); + if (debug_linux_nat) + fprintf_unfiltered (gdb_stderr, + "FC: Wait finished; saved status is %d\n", + lp->status); + } + + return 0; +} + +/* Return non-zero if LP has a wait status pending. */ + +static int +status_callback (struct lwp_info *lp, void *data) +{ + /* Only report a pending wait status if we pretend that this has + indeed been resumed. */ + return (lp->status != 0 && lp->resumed); +} + +/* Return non-zero if LP isn't stopped. */ + +static int +running_callback (struct lwp_info *lp, void *data) +{ + return (lp->stopped == 0 || (lp->status != 0 && lp->resumed)); +} + +/* Count the LWP's that have had events. */ + +static int +count_events_callback (struct lwp_info *lp, void *data) +{ + int *count = data; + + gdb_assert (count != NULL); + + /* Count only LWPs that have a SIGTRAP event pending. */ + if (lp->status != 0 + && WIFSTOPPED (lp->status) && WSTOPSIG (lp->status) == SIGTRAP) + (*count)++; + + return 0; +} + +/* Select the LWP (if any) that is currently being single-stepped. */ + +static int +select_singlestep_lwp_callback (struct lwp_info *lp, void *data) +{ + if (lp->step && lp->status != 0) + return 1; + else + return 0; +} + +/* Select the Nth LWP that has had a SIGTRAP event. */ + +static int +select_event_lwp_callback (struct lwp_info *lp, void *data) +{ + int *selector = data; + + gdb_assert (selector != NULL); + + /* Select only LWPs that have a SIGTRAP event pending. */ + if (lp->status != 0 + && WIFSTOPPED (lp->status) && WSTOPSIG (lp->status) == SIGTRAP) + if ((*selector)-- == 0) + return 1; + + return 0; +} + +static int +cancel_breakpoints_callback (struct lwp_info *lp, void *data) +{ + struct lwp_info *event_lp = data; + + /* Leave the LWP that has been elected to receive a SIGTRAP alone. */ + if (lp == event_lp) + return 0; + + /* If a LWP other than the LWP that we're reporting an event for has + hit a GDB breakpoint (as opposed to some random trap signal), + then just arrange for it to hit it again later. We don't keep + the SIGTRAP status and don't forward the SIGTRAP signal to the + LWP. We will handle the current event, eventually we will resume + all LWPs, and this one will get its breakpoint trap again. + + If we do not do this, then we run the risk that the user will + delete or disable the breakpoint, but the LWP will have already + tripped on it. */ + + if (lp->status != 0 + && WIFSTOPPED (lp->status) && WSTOPSIG (lp->status) == SIGTRAP + && breakpoint_inserted_here_p (read_pc_pid (lp->ptid) - + DECR_PC_AFTER_BREAK)) + { + if (debug_linux_nat) + fprintf_unfiltered (gdb_stdlog, + "CBC: Push back breakpoint for %s\n", + target_pid_to_str (lp->ptid)); + + /* Back up the PC if necessary. */ + if (DECR_PC_AFTER_BREAK) + write_pc_pid (read_pc_pid (lp->ptid) - DECR_PC_AFTER_BREAK, lp->ptid); + + /* Throw away the SIGTRAP. */ + lp->status = 0; + } + + return 0; +} + +/* Select one LWP out of those that have events pending. */ + +static void +select_event_lwp (struct lwp_info **orig_lp, int *status) +{ + int num_events = 0; + int random_selector; + struct lwp_info *event_lp; + + /* Record the wait status for the origional LWP. */ + (*orig_lp)->status = *status; + + /* Give preference to any LWP that is being single-stepped. */ + event_lp = iterate_over_lwps (select_singlestep_lwp_callback, NULL); + if (event_lp != NULL) + { + if (debug_linux_nat) + fprintf_unfiltered (gdb_stdlog, + "SEL: Select single-step %s\n", + target_pid_to_str (event_lp->ptid)); + } + else + { + /* No single-stepping LWP. Select one at random, out of those + which have had SIGTRAP events. */ + + /* First see how many SIGTRAP events we have. */ + iterate_over_lwps (count_events_callback, &num_events); + + /* Now randomly pick a LWP out of those that have had a SIGTRAP. */ + random_selector = (int) + ((num_events * (double) rand ()) / (RAND_MAX + 1.0)); + + if (debug_linux_nat && num_events > 1) + fprintf_unfiltered (gdb_stdlog, + "SEL: Found %d SIGTRAP events, selecting #%d\n", + num_events, random_selector); + + event_lp = iterate_over_lwps (select_event_lwp_callback, + &random_selector); + } + + if (event_lp != NULL) + { + /* Switch the event LWP. */ + *orig_lp = event_lp; + *status = event_lp->status; + } + + /* Flush the wait status for the event LWP. */ + (*orig_lp)->status = 0; +} + +/* Return non-zero if LP has been resumed. */ + +static int +resumed_callback (struct lwp_info *lp, void *data) +{ + return lp->resumed; +} + +#ifdef CHILD_WAIT + +/* We need to override child_wait to support attaching to cloned + processes, since a normal wait (as done by the default version) + ignores those processes. */ + +/* Wait for child PTID to do something. Return id of the child, + minus_one_ptid in case of error; store status into *OURSTATUS. */ + +ptid_t +child_wait (ptid_t ptid, struct target_waitstatus *ourstatus) +{ + int save_errno; + int status; + pid_t pid; + + ourstatus->kind = TARGET_WAITKIND_IGNORE; + + do + { + set_sigint_trap (); /* Causes SIGINT to be passed on to the + attached process. */ + set_sigio_trap (); + + pid = waitpid (GET_PID (ptid), &status, 0); + if (pid == -1 && errno == ECHILD) + /* Try again with __WCLONE to check cloned processes. */ + pid = waitpid (GET_PID (ptid), &status, __WCLONE); + + if (debug_linux_nat) + { + fprintf_unfiltered (gdb_stdlog, + "CW: waitpid %ld received %s\n", + (long) pid, status_to_str (status)); + } + + save_errno = errno; + + /* Make sure we don't report an event for the exit of the + original program, if we've detached from it. */ + if (pid != -1 && !WIFSTOPPED (status) && pid != GET_PID (inferior_ptid)) + { + pid = -1; + save_errno = EINTR; + } + + /* Check for stop events reported by a process we didn't already + know about - in this case, anything other than inferior_ptid. + + If we're expecting to receive stopped processes after fork, + vfork, and clone events, then we'll just add the new one to + our list and go back to waiting for the event to be reported + - the stopped process might be returned from waitpid before + or after the event is. If we want to handle debugging of + CLONE_PTRACE processes we need to do more here, i.e. switch + to multi-threaded mode. */ + if (pid != -1 && WIFSTOPPED (status) && WSTOPSIG (status) == SIGSTOP + && pid != GET_PID (inferior_ptid)) + { + linux_record_stopped_pid (pid); + pid = -1; + save_errno = EINTR; + } + + /* Handle GNU/Linux's extended waitstatus for trace events. */ + if (pid != -1 && WIFSTOPPED (status) && WSTOPSIG (status) == SIGTRAP + && status >> 16 != 0) + { + linux_handle_extended_wait (pid, status, ourstatus); + + /* If we see a clone event, detach the child, and don't + report the event. It would be nice to offer some way to + switch into a non-thread-db based threaded mode at this + point. */ + if (ourstatus->kind == TARGET_WAITKIND_SPURIOUS) + { + ptrace (PTRACE_DETACH, ourstatus->value.related_pid, 0, 0); + ourstatus->kind = TARGET_WAITKIND_IGNORE; + ptrace (PTRACE_CONT, pid, 0, 0); + pid = -1; + save_errno = EINTR; + } + } + + clear_sigio_trap (); + clear_sigint_trap (); + } + while (pid == -1 && save_errno == EINTR); + + if (pid == -1) + { + warning ("Child process unexpectedly missing: %s", + safe_strerror (errno)); + + /* Claim it exited with unknown signal. */ + ourstatus->kind = TARGET_WAITKIND_SIGNALLED; + ourstatus->value.sig = TARGET_SIGNAL_UNKNOWN; + return minus_one_ptid; + } + + if (ourstatus->kind == TARGET_WAITKIND_IGNORE) + store_waitstatus (ourstatus, status); + + return pid_to_ptid (pid); +} + +#endif + +/* Stop an active thread, verify it still exists, then resume it. */ + +static int +stop_and_resume_callback (struct lwp_info *lp, void *data) +{ + struct lwp_info *ptr; + + if (!lp->stopped && !lp->signalled) + { + stop_callback (lp, NULL); + stop_wait_callback (lp, NULL); + /* Resume if the lwp still exists. */ + for (ptr = lwp_list; ptr; ptr = ptr->next) + if (lp == ptr) + { + resume_callback (lp, NULL); + resume_set_callback (lp, NULL); + } + } + return 0; +} + +static ptid_t +linux_nat_wait (ptid_t ptid, struct target_waitstatus *ourstatus) +{ + struct lwp_info *lp = NULL; + int options = 0; + int status = 0; + pid_t pid = PIDGET (ptid); + sigset_t flush_mask; + + sigemptyset (&flush_mask); + + /* Make sure SIGCHLD is blocked. */ + if (!sigismember (&blocked_mask, SIGCHLD)) + { + sigaddset (&blocked_mask, SIGCHLD); + sigprocmask (SIG_BLOCK, &blocked_mask, NULL); + } + +retry: + + /* Make sure there is at least one LWP that has been resumed, at + least if there are any LWPs at all. */ + gdb_assert (num_lwps == 0 || iterate_over_lwps (resumed_callback, NULL)); + + /* First check if there is a LWP with a wait status pending. */ + if (pid == -1) + { + /* Any LWP that's been resumed will do. */ + lp = iterate_over_lwps (status_callback, NULL); + if (lp) + { + status = lp->status; + lp->status = 0; + + if (debug_linux_nat && status) + fprintf_unfiltered (gdb_stdlog, + "LLW: Using pending wait status %s for %s.\n", + status_to_str (status), + target_pid_to_str (lp->ptid)); + } + + /* But if we don't fine one, we'll have to wait, and check both + cloned and uncloned processes. We start with the cloned + processes. */ + options = __WCLONE | WNOHANG; + } + else if (is_lwp (ptid)) + { + if (debug_linux_nat) + fprintf_unfiltered (gdb_stdlog, + "LLW: Waiting for specific LWP %s.\n", + target_pid_to_str (ptid)); + + /* We have a specific LWP to check. */ + lp = find_lwp_pid (ptid); + gdb_assert (lp); + status = lp->status; + lp->status = 0; + + if (debug_linux_nat && status) + fprintf_unfiltered (gdb_stdlog, + "LLW: Using pending wait status %s for %s.\n", + status_to_str (status), + target_pid_to_str (lp->ptid)); + + /* If we have to wait, take into account whether PID is a cloned + process or not. And we have to convert it to something that + the layer beneath us can understand. */ + options = lp->cloned ? __WCLONE : 0; + pid = GET_LWP (ptid); + } + + if (status && lp->signalled) + { + /* A pending SIGSTOP may interfere with the normal stream of + events. In a typical case where interference is a problem, + we have a SIGSTOP signal pending for LWP A while + single-stepping it, encounter an event in LWP B, and take the + pending SIGSTOP while trying to stop LWP A. After processing + the event in LWP B, LWP A is continued, and we'll never see + the SIGTRAP associated with the last time we were + single-stepping LWP A. */ + + /* Resume the thread. It should halt immediately returning the + pending SIGSTOP. */ + registers_changed (); + child_resume (pid_to_ptid (GET_LWP (lp->ptid)), lp->step, + TARGET_SIGNAL_0); + if (debug_linux_nat) + fprintf_unfiltered (gdb_stdlog, + "LLW: %s %s, 0, 0 (expect SIGSTOP)\n", + lp->step ? "PTRACE_SINGLESTEP" : "PTRACE_CONT", + target_pid_to_str (lp->ptid)); + lp->stopped = 0; + gdb_assert (lp->resumed); + + /* This should catch the pending SIGSTOP. */ + stop_wait_callback (lp, NULL); + } + + set_sigint_trap (); /* Causes SIGINT to be passed on to the + attached process. */ + set_sigio_trap (); + + while (status == 0) + { + pid_t lwpid; + + lwpid = waitpid (pid, &status, options); + if (lwpid > 0) + { + gdb_assert (pid == -1 || lwpid == pid); + + if (debug_linux_nat) + { + fprintf_unfiltered (gdb_stdlog, + "LLW: waitpid %ld received %s\n", + (long) lwpid, status_to_str (status)); + } + + lp = find_lwp_pid (pid_to_ptid (lwpid)); + + /* Check for stop events reported by a process we didn't + already know about - anything not already in our LWP + list. + + If we're expecting to receive stopped processes after + fork, vfork, and clone events, then we'll just add the + new one to our list and go back to waiting for the event + to be reported - the stopped process might be returned + from waitpid before or after the event is. */ + if (WIFSTOPPED (status) && !lp) + { + linux_record_stopped_pid (lwpid); + status = 0; + continue; + } + + /* Make sure we don't report an event for the exit of an LWP not in + our list, i.e. not part of the current process. This can happen + if we detach from a program we original forked and then it + exits. */ + if (!WIFSTOPPED (status) && !lp) + { + status = 0; + continue; + } + + /* NOTE drow/2003-06-17: This code seems to be meant for debugging + CLONE_PTRACE processes which do not use the thread library - + otherwise we wouldn't find the new LWP this way. That doesn't + currently work, and the following code is currently unreachable + due to the two blocks above. If it's fixed some day, this code + should be broken out into a function so that we can also pick up + LWPs from the new interface. */ + if (!lp) + { + lp = add_lwp (BUILD_LWP (lwpid, GET_PID (inferior_ptid))); + if (options & __WCLONE) + lp->cloned = 1; + + if (threaded) + { + gdb_assert (WIFSTOPPED (status) + && WSTOPSIG (status) == SIGSTOP); + lp->signalled = 1; + + if (!in_thread_list (inferior_ptid)) + { + inferior_ptid = BUILD_LWP (GET_PID (inferior_ptid), + GET_PID (inferior_ptid)); + add_thread (inferior_ptid); + } + + add_thread (lp->ptid); + printf_unfiltered ("[New %s]\n", + target_pid_to_str (lp->ptid)); + } + } + + /* Handle GNU/Linux's extended waitstatus for trace events. */ + if (WIFSTOPPED (status) && WSTOPSIG (status) == SIGTRAP && status >> 16 != 0) + { + if (debug_linux_nat) + fprintf_unfiltered (gdb_stdlog, + "LLW: Handling extended status 0x%06x\n", + status); + if (linux_nat_handle_extended (lp, status)) + { + status = 0; + continue; + } + } + + /* Check if the thread has exited. */ + if ((WIFEXITED (status) || WIFSIGNALED (status)) && num_lwps > 1) + { + if (in_thread_list (lp->ptid)) + { + /* Core GDB cannot deal with us deleting the current + thread. */ + if (!ptid_equal (lp->ptid, inferior_ptid)) + delete_thread (lp->ptid); + printf_unfiltered ("[%s exited]\n", + target_pid_to_str (lp->ptid)); + } + + /* If this is the main thread, we must stop all threads and + verify if they are still alive. This is because in the nptl + thread model, there is no signal issued for exiting LWPs + other than the main thread. We only get the main thread + exit signal once all child threads have already exited. + If we stop all the threads and use the stop_wait_callback + to check if they have exited we can determine whether this + signal should be ignored or whether it means the end of the + debugged application, regardless of which threading model + is being used. */ + if (GET_PID (lp->ptid) == GET_LWP (lp->ptid)) + { + lp->stopped = 1; + iterate_over_lwps (stop_and_resume_callback, NULL); + } + + if (debug_linux_nat) + fprintf_unfiltered (gdb_stdlog, + "LLW: %s exited.\n", + target_pid_to_str (lp->ptid)); + + delete_lwp (lp->ptid); + + /* If there is at least one more LWP, then the exit signal + was not the end of the debugged application and should be + ignored. */ + if (num_lwps > 0) + { + /* Make sure there is at least one thread running. */ + gdb_assert (iterate_over_lwps (running_callback, NULL)); + + /* Discard the event. */ + status = 0; + continue; + } + } + + /* Check if the current LWP has previously exited. In the nptl + thread model, LWPs other than the main thread do not issue + signals when they exit so we must check whenever the thread + has stopped. A similar check is made in stop_wait_callback(). */ + if (num_lwps > 1 && !linux_nat_thread_alive (lp->ptid)) + { + if (in_thread_list (lp->ptid)) + { + /* Core GDB cannot deal with us deleting the current + thread. */ + if (!ptid_equal (lp->ptid, inferior_ptid)) + delete_thread (lp->ptid); + printf_unfiltered ("[%s exited]\n", + target_pid_to_str (lp->ptid)); + } + if (debug_linux_nat) + fprintf_unfiltered (gdb_stdlog, + "LLW: %s exited.\n", + target_pid_to_str (lp->ptid)); + + delete_lwp (lp->ptid); + + /* Make sure there is at least one thread running. */ + gdb_assert (iterate_over_lwps (running_callback, NULL)); + + /* Discard the event. */ + status = 0; + continue; + } + + /* Make sure we don't report a SIGSTOP that we sent + ourselves in an attempt to stop an LWP. */ + if (lp->signalled + && WIFSTOPPED (status) && WSTOPSIG (status) == SIGSTOP) + { + if (debug_linux_nat) + fprintf_unfiltered (gdb_stdlog, + "LLW: Delayed SIGSTOP caught for %s.\n", + target_pid_to_str (lp->ptid)); + + /* This is a delayed SIGSTOP. */ + lp->signalled = 0; + + registers_changed (); + child_resume (pid_to_ptid (GET_LWP (lp->ptid)), lp->step, + TARGET_SIGNAL_0); + if (debug_linux_nat) + fprintf_unfiltered (gdb_stdlog, + "LLW: %s %s, 0, 0 (discard SIGSTOP)\n", + lp->step ? + "PTRACE_SINGLESTEP" : "PTRACE_CONT", + target_pid_to_str (lp->ptid)); + + lp->stopped = 0; + gdb_assert (lp->resumed); + + /* Discard the event. */ + status = 0; + continue; + } + + break; + } + + if (pid == -1) + { + /* Alternate between checking cloned and uncloned processes. */ + options ^= __WCLONE; + + /* And suspend every time we have checked both. */ + if (options & __WCLONE) + sigsuspend (&suspend_mask); + } + + /* We shouldn't end up here unless we want to try again. */ + gdb_assert (status == 0); + } + + clear_sigio_trap (); + clear_sigint_trap (); + + gdb_assert (lp); + + /* Don't report signals that GDB isn't interested in, such as + signals that are neither printed nor stopped upon. Stopping all + threads can be a bit time-consuming so if we want decent + performance with heavily multi-threaded programs, especially when + they're using a high frequency timer, we'd better avoid it if we + can. */ + + if (WIFSTOPPED (status)) + { + int signo = target_signal_from_host (WSTOPSIG (status)); + + if (signal_stop_state (signo) == 0 + && signal_print_state (signo) == 0 + && signal_pass_state (signo) == 1) + { + /* FIMXE: kettenis/2001-06-06: Should we resume all threads + here? It is not clear we should. GDB may not expect + other threads to run. On the other hand, not resuming + newly attached threads may cause an unwanted delay in + getting them running. */ + registers_changed (); + child_resume (pid_to_ptid (GET_LWP (lp->ptid)), lp->step, signo); + if (debug_linux_nat) + fprintf_unfiltered (gdb_stdlog, + "LLW: %s %s, %s (preempt 'handle')\n", + lp->step ? + "PTRACE_SINGLESTEP" : "PTRACE_CONT", + target_pid_to_str (lp->ptid), + signo ? strsignal (signo) : "0"); + lp->stopped = 0; + status = 0; + goto retry; + } + + if (signo == TARGET_SIGNAL_INT && signal_pass_state (signo) == 0) + { + /* If ^C/BREAK is typed at the tty/console, SIGINT gets + forwarded to the entire process group, that is, all LWP's + will receive it. Since we only want to report it once, + we try to flush it from all LWPs except this one. */ + sigaddset (&flush_mask, SIGINT); + } + } + + /* This LWP is stopped now. */ + lp->stopped = 1; + + if (debug_linux_nat) + fprintf_unfiltered (gdb_stdlog, "LLW: Candidate event %s in %s.\n", + status_to_str (status), target_pid_to_str (lp->ptid)); + + /* Now stop all other LWP's ... */ + iterate_over_lwps (stop_callback, NULL); + + /* ... and wait until all of them have reported back that they're no + longer running. */ + iterate_over_lwps (stop_wait_callback, &flush_mask); + iterate_over_lwps (flush_callback, &flush_mask); + + /* If we're not waiting for a specific LWP, choose an event LWP from + among those that have had events. Giving equal priority to all + LWPs that have had events helps prevent starvation. */ + if (pid == -1) + select_event_lwp (&lp, &status); + + /* Now that we've selected our final event LWP, cancel any + breakpoints in other LWPs that have hit a GDB breakpoint. See + the comment in cancel_breakpoints_callback to find out why. */ + iterate_over_lwps (cancel_breakpoints_callback, lp); + + /* If we're not running in "threaded" mode, we'll report the bare + process id. */ + + if (WIFSTOPPED (status) && WSTOPSIG (status) == SIGTRAP) + { + trap_ptid = (threaded ? lp->ptid : pid_to_ptid (GET_LWP (lp->ptid))); + if (debug_linux_nat) + fprintf_unfiltered (gdb_stdlog, + "LLW: trap_ptid is %s.\n", + target_pid_to_str (trap_ptid)); + } + else + trap_ptid = null_ptid; + + if (lp->waitstatus.kind != TARGET_WAITKIND_IGNORE) + { + *ourstatus = lp->waitstatus; + lp->waitstatus.kind = TARGET_WAITKIND_IGNORE; + } + else + store_waitstatus (ourstatus, status); + + return (threaded ? lp->ptid : pid_to_ptid (GET_LWP (lp->ptid))); +} + +static int +kill_callback (struct lwp_info *lp, void *data) +{ + errno = 0; + ptrace (PTRACE_KILL, GET_LWP (lp->ptid), 0, 0); + if (debug_linux_nat) + fprintf_unfiltered (gdb_stdlog, + "KC: PTRACE_KILL %s, 0, 0 (%s)\n", + target_pid_to_str (lp->ptid), + errno ? safe_strerror (errno) : "OK"); + + return 0; +} + +static int +kill_wait_callback (struct lwp_info *lp, void *data) +{ + pid_t pid; + + /* We must make sure that there are no pending events (delayed + SIGSTOPs, pending SIGTRAPs, etc.) to make sure the current + program doesn't interfere with any following debugging session. */ + + /* For cloned processes we must check both with __WCLONE and + without, since the exit status of a cloned process isn't reported + with __WCLONE. */ + if (lp->cloned) + { + do + { + pid = waitpid (GET_LWP (lp->ptid), NULL, __WCLONE); + if (pid != (pid_t) -1 && debug_linux_nat) + { + fprintf_unfiltered (gdb_stdlog, + "KWC: wait %s received unknown.\n", + target_pid_to_str (lp->ptid)); + } + } + while (pid == GET_LWP (lp->ptid)); + + gdb_assert (pid == -1 && errno == ECHILD); + } + + do + { + pid = waitpid (GET_LWP (lp->ptid), NULL, 0); + if (pid != (pid_t) -1 && debug_linux_nat) + { + fprintf_unfiltered (gdb_stdlog, + "KWC: wait %s received unk.\n", + target_pid_to_str (lp->ptid)); + } + } + while (pid == GET_LWP (lp->ptid)); + + gdb_assert (pid == -1 && errno == ECHILD); + return 0; +} + +static void +linux_nat_kill (void) +{ + /* Kill all LWP's ... */ + iterate_over_lwps (kill_callback, NULL); + + /* ... and wait until we've flushed all events. */ + iterate_over_lwps (kill_wait_callback, NULL); + + target_mourn_inferior (); +} + +static void +linux_nat_create_inferior (char *exec_file, char *allargs, char **env, + int from_tty) +{ + child_ops.to_create_inferior (exec_file, allargs, env, from_tty); +} + +static void +linux_nat_mourn_inferior (void) +{ + trap_ptid = null_ptid; + + /* Destroy LWP info; it's no longer valid. */ + init_lwp_list (); + + /* Restore the original signal mask. */ + sigprocmask (SIG_SETMASK, &normal_mask, NULL); + sigemptyset (&blocked_mask); + + child_ops.to_mourn_inferior (); +} + +static int +linux_nat_xfer_memory (CORE_ADDR memaddr, char *myaddr, int len, int write, + struct mem_attrib *attrib, struct target_ops *target) +{ + struct cleanup *old_chain = save_inferior_ptid (); + int xfer; + + if (is_lwp (inferior_ptid)) + inferior_ptid = pid_to_ptid (GET_LWP (inferior_ptid)); + + xfer = linux_proc_xfer_memory (memaddr, myaddr, len, write, attrib, target); + if (xfer == 0) + xfer = child_xfer_memory (memaddr, myaddr, len, write, attrib, target); + + do_cleanups (old_chain); + return xfer; +} + +static int +linux_nat_thread_alive (ptid_t ptid) +{ + gdb_assert (is_lwp (ptid)); + + errno = 0; + ptrace (PTRACE_PEEKUSER, GET_LWP (ptid), 0, 0); + if (debug_linux_nat) + fprintf_unfiltered (gdb_stdlog, + "LLTA: PTRACE_PEEKUSER %s, 0, 0 (%s)\n", + target_pid_to_str (ptid), + errno ? safe_strerror (errno) : "OK"); + if (errno) + return 0; + + return 1; +} + +static char * +linux_nat_pid_to_str (ptid_t ptid) +{ + static char buf[64]; + + if (is_lwp (ptid)) + { + snprintf (buf, sizeof (buf), "LWP %ld", GET_LWP (ptid)); + return buf; + } + + return normal_pid_to_str (ptid); +} + +static void +init_linux_nat_ops (void) +{ +#if 0 + linux_nat_ops.to_open = linux_nat_open; +#endif + linux_nat_ops.to_shortname = "lwp-layer"; + linux_nat_ops.to_longname = "lwp-layer"; + linux_nat_ops.to_doc = "Low level threads support (LWP layer)"; + linux_nat_ops.to_attach = linux_nat_attach; + linux_nat_ops.to_detach = linux_nat_detach; + linux_nat_ops.to_resume = linux_nat_resume; + linux_nat_ops.to_wait = linux_nat_wait; + /* fetch_inferior_registers and store_inferior_registers will + honor the LWP id, so we can use them directly. */ + linux_nat_ops.to_fetch_registers = fetch_inferior_registers; + linux_nat_ops.to_store_registers = store_inferior_registers; + linux_nat_ops.to_xfer_memory = linux_nat_xfer_memory; + linux_nat_ops.to_kill = linux_nat_kill; + linux_nat_ops.to_create_inferior = linux_nat_create_inferior; + linux_nat_ops.to_mourn_inferior = linux_nat_mourn_inferior; + linux_nat_ops.to_thread_alive = linux_nat_thread_alive; + linux_nat_ops.to_pid_to_str = linux_nat_pid_to_str; + linux_nat_ops.to_post_startup_inferior = child_post_startup_inferior; + linux_nat_ops.to_post_attach = child_post_attach; + linux_nat_ops.to_insert_fork_catchpoint = child_insert_fork_catchpoint; + linux_nat_ops.to_insert_vfork_catchpoint = child_insert_vfork_catchpoint; + linux_nat_ops.to_insert_exec_catchpoint = child_insert_exec_catchpoint; + + linux_nat_ops.to_stratum = thread_stratum; + linux_nat_ops.to_has_thread_control = tc_schedlock; + linux_nat_ops.to_magic = OPS_MAGIC; +} + +static void +sigchld_handler (int signo) +{ + /* Do nothing. The only reason for this handler is that it allows + us to use sigsuspend in linux_nat_wait above to wait for the + arrival of a SIGCHLD. */ +} + +void +_initialize_linux_nat (void) +{ + struct sigaction action; + + extern void thread_db_init (struct target_ops *); + + init_linux_nat_ops (); + add_target (&linux_nat_ops); + thread_db_init (&linux_nat_ops); + + /* Save the original signal mask. */ + sigprocmask (SIG_SETMASK, NULL, &normal_mask); + + action.sa_handler = sigchld_handler; + sigemptyset (&action.sa_mask); + action.sa_flags = 0; + sigaction (SIGCHLD, &action, NULL); + + /* Make sure we don't block SIGCHLD during a sigsuspend. */ + sigprocmask (SIG_SETMASK, NULL, &suspend_mask); + sigdelset (&suspend_mask, SIGCHLD); + + sigemptyset (&blocked_mask); + + deprecated_add_show_from_set + (add_set_cmd ("lin-lwp", no_class, var_zinteger, + (char *) &debug_linux_nat, + "Set debugging of GNU/Linux lwp module.\n\ +Enables printf debugging output.\n", &setdebuglist), &showdebuglist); +} + + +/* FIXME: kettenis/2000-08-26: The stuff on this page is specific to + the GNU/Linux Threads library and therefore doesn't really belong + here. */ + +/* Read variable NAME in the target and return its value if found. + Otherwise return zero. It is assumed that the type of the variable + is `int'. */ + +static int +get_signo (const char *name) +{ + struct minimal_symbol *ms; + int signo; + + ms = lookup_minimal_symbol (name, NULL, NULL); + if (ms == NULL) + return 0; + + if (target_read_memory (SYMBOL_VALUE_ADDRESS (ms), (char *) &signo, + sizeof (signo)) != 0) + return 0; + + return signo; +} + +/* Return the set of signals used by the threads library in *SET. */ + +void +lin_thread_get_thread_signals (sigset_t *set) +{ + struct sigaction action; + int restart, cancel; + + sigemptyset (set); + + restart = get_signo ("__pthread_sig_restart"); + if (restart == 0) + return; + + cancel = get_signo ("__pthread_sig_cancel"); + if (cancel == 0) + return; + + sigaddset (set, restart); + sigaddset (set, cancel); + + /* The GNU/Linux Threads library makes terminating threads send a + special "cancel" signal instead of SIGCHLD. Make sure we catch + those (to prevent them from terminating GDB itself, which is + likely to be their default action) and treat them the same way as + SIGCHLD. */ + + action.sa_handler = sigchld_handler; + sigemptyset (&action.sa_mask); + action.sa_flags = 0; + sigaction (cancel, &action, NULL); + + /* We block the "cancel" signal throughout this code ... */ + sigaddset (&blocked_mask, cancel); + sigprocmask (SIG_BLOCK, &blocked_mask, NULL); + + /* ... except during a sigsuspend. */ + sigdelset (&suspend_mask, cancel); +} |