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.

17 files changed, 1979 insertions, 1988 deletions

diff --git a/gdb/ChangeLog b/gdb/ChangeLog
index b34e7a33776..323dec4e628 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 900c919f02b..7f84623a1c0 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 d3cbff7ff39..a927762ce2d 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 af5b546a7dc..aa252cf3a6c 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 3714e0c2787..146b855c9bc 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 1622f18c7c2..9fbba56629e 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 71fed101a3e..2468c67695d 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 69dce24a01c..42231d97b95 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 3fbc3e9dc74..d282c968243 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 596857c0b9c..7553d2443c9 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 450a7775c2e..a207d3223e0 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 b22408a9e4d..4c35f3bff29 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 3db7bd91f99..7bf24f8dc6f 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 ed68cc78aea..bc0644fb485 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 c1472de8de8..0cc8f01b9d0 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 5971630f9e8..00000000000
--- 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 15b67042290..6207e4d3701 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);
+}