2006-01-04 Michael Snyder <msnyder@redhat.com>

	Checkpoint/Restart for Linux.
	* linux-nat.c: Add support for debugging multiple forks.
	Add #include for linux-fork.h (interface spec).
	(super_mourn_inferior): New function pointer.
	(child_mourn_inferior): New function / target method.
	(linux_target): Claim to_mourn_inferior method pointer.
	(child_follow_fork): Call interface to linux-fork, conditionally
	add new fork processes to list of debugged processes.
	(kill_inferior): Use interface to linux-fork to kill
	multiple processes.

	* linux-fork.h: New file.
	* linux-fork.c: New file.  Support for debugging multiple forks
	of the same program.  Support for checkpoint and restart commands.

	* infrun.c (nullify_last_target_wait_ptid): New function.

	* Makefile.in: Add linux-fork.
	* config/*/linux.mh: Add linux-fork.
	* NEWS: Mention new functionality.

20 files changed, 901 insertions, 50 deletions

diff --git a/gdb/ChangeLog b/gdb/ChangeLog
index 0929ab2..d2dbf3a 100644
--- a/gdb/ChangeLog
+++ b/gdb/ChangeLog
@@ -1,3 +1,26 @@
+2006-01-04  Michael Snyder  <msnyder@redhat.com>
+
+	Checkpoint/Restart for Linux.
+	* linux-nat.c: Add support for debugging multiple forks.
+	Add #include for linux-fork.h (interface spec).
+	(super_mourn_inferior): New function pointer.
+	(child_mourn_inferior): New function / target method.
+	(linux_target): Claim to_mourn_inferior method pointer.
+	(child_follow_fork): Call interface to linux-fork, conditionally
+	add new fork processes to list of debugged processes.
+	(kill_inferior): Use interface to linux-fork to kill
+	multiple processes.
+
+	* linux-fork.h: New file.
+	* linux-fork.c: New file.  Support for debugging multiple forks
+	of the same program.  Support for checkpoint and restart commands.
+
+	* infrun.c (nullify_last_target_wait_ptid): New function.
+
+	* Makefile.in: Add linux-fork.
+	* config/*/linux.mh: Add linux-fork.
+	* NEWS: Mention new functionality.
+
 2006-01-02  Paul Hilfinger  <hilfingr@nile.gnat.com>
 
 	* ada-exp.y (syntax definitions,write_var_or_type,write_name_assoc): 
diff --git a/gdb/Makefile.in b/gdb/Makefile.in
index bd6b96f..9c52d6c 100644
--- a/gdb/Makefile.in
+++ b/gdb/Makefile.in
@@ -1377,7 +1377,7 @@ MAKEOVERRIDES=
 
 ALLDEPFILES = \
 	aix-thread.c \
-	alpha-nat.c alphabsd-nat.c alpha-linux-nat.c \
+	alpha-nat.c alphabsd-nat.c alpha-linux-nat.c linux-fork.c \
 	alpha-tdep.c alpha-linux-tdep.c alphabsd-tdep.c alphanbsd-tdep.c \
 	alpha-osf1-tdep.c alphafbsd-tdep.c alpha-mdebug-tdep.c \
 	amd64-nat.c amd64-tdep.c \
@@ -2180,10 +2180,12 @@ linespec.o: linespec.c $(defs_h) $(symtab_h) $(frame_h) $(command_h) \
 	$(symfile_h) $(objfiles_h) $(source_h) $(demangle_h) $(value_h) \
 	$(completer_h) $(cp_abi_h) $(parser_defs_h) $(block_h) \
 	$(objc_lang_h) $(linespec_h) $(exceptions_h)
+linux-fork.o: linux-fork.c linux-fork.h $(defs_h) $(inferior_h) \
+	$(regcache_h) $(gdbcmd_h) $(infcall_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) $(inf_ptrace.h) $(auxv.h) $(elf_bfd_h) \
-	$(gregset_h) $(gdbcore_h) $(gdbthread_h) $(gdb_stat_h)
+	$(gregset_h) $(gdbcore_h) $(gdbthread_h) $(gdb_stat_h) linux-fork.h
 linux-thread-db.o: linux-thread-db.c $(defs_h) $(gdb_assert_h) \
 	$(gdb_proc_service_h) $(gdb_thread_db_h) $(bfd_h) $(exceptions_h) \
 	$(gdbthread_h) $(inferior_h) $(symfile_h) $(objfiles_h) $(target_h) \
diff --git a/gdb/NEWS b/gdb/NEWS
index c882cb3..aa1b913 100644
--- a/gdb/NEWS
+++ b/gdb/NEWS
@@ -8,6 +8,35 @@
 init-if-undefined		Initialize a convenience variable, but
 				only if it doesn't already have a value.
 
+The following commands are presently only implemented for native GNU/Linux:
+
+checkpoint			Save a snapshot of the program state.
+
+restart	<n>			Return the program state to a 
+				previously saved state.
+
+info checkpoints		List currently saved checkpoints.
+
+delete-checkpoint <n>		Delete a previously saved checkpoint.
+
+set|show detach-on-fork		Tell gdb whether to detach from a newly
+				forked process, or to keep debugging it.
+
+info forks			List forks of the user program that
+				are available to be debugged.
+
+fork <n>			Switch to debugging one of several
+				forks of the user program that are
+				available to be debugged.
+
+delete-fork <n>			Delete a fork from the list of forks
+				that are available to be debugged (and
+				kill the forked process).
+
+detach-fork <n>			Delete a fork from the list of forks
+				that are available to be debugged (and
+				allow the process to continue).
+
 * New architecture
 
 Morpho Technologies ms2		ms1-elf
diff --git a/gdb/config/alpha/alpha-linux.mh b/gdb/config/alpha/alpha-linux.mh
index 5ee0ec3..28a50c1 100644
--- a/gdb/config/alpha/alpha-linux.mh
+++ b/gdb/config/alpha/alpha-linux.mh
@@ -2,7 +2,7 @@
 NAT_FILE= nm-linux.h
 NATDEPFILES= inf-ptrace.o corelow.o alpha-nat.o alpha-linux-nat.o \
 	fork-child.o proc-service.o linux-thread-db.o gcore.o \
-	linux-nat.o
+	linux-nat.o linux-fork.o
 
 # The dynamically loaded libthread_db needs access to symbols in the
 # gdb executable.
diff --git a/gdb/config/arm/linux.mh b/gdb/config/arm/linux.mh
index 34a1689..32181a4 100644
--- a/gdb/config/arm/linux.mh
+++ b/gdb/config/arm/linux.mh
@@ -3,7 +3,7 @@
 NAT_FILE= nm-linux.h
 NATDEPFILES= inf-ptrace.o fork-child.o corelow.o	\
 	core-regset.o arm-linux-nat.o gcore.o	\
-	proc-service.o linux-thread-db.o linux-nat.o
+	proc-service.o linux-thread-db.o linux-nat.o linux-fork.o
 
 LOADLIBES= -ldl -rdynamic
 
diff --git a/gdb/config/i386/linux.mh b/gdb/config/i386/linux.mh
index ec058a5..62fff99 100644
--- a/gdb/config/i386/linux.mh
+++ b/gdb/config/i386/linux.mh
@@ -4,7 +4,7 @@ NAT_FILE= nm-linux.h
 NATDEPFILES= inf-ptrace.o fork-child.o corelow.o \
 	core-aout.o i386-nat.o i386-linux-nat.o \
 	proc-service.o linux-thread-db.o gcore.o \
-	linux-nat.o
+	linux-nat.o linux-fork.o
 
 # The dynamically loaded libthread_db needs access to symbols in the
 # gdb executable.
diff --git a/gdb/config/i386/linux64.mh b/gdb/config/i386/linux64.mh
index b764ca5..1c03d71 100644
--- a/gdb/config/i386/linux64.mh
+++ b/gdb/config/i386/linux64.mh
@@ -1,7 +1,7 @@
 # Host: GNU/Linux x86-64
 NATDEPFILES= inf-ptrace.o fork-child.o \
 	i386-nat.o amd64-nat.o amd64-linux-nat.o linux-nat.o \
-	proc-service.o linux-thread-db.o gcore.o 
+	proc-service.o linux-thread-db.o gcore.o  linux-fork.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 2e43f33..3ae22b2 100644
--- a/gdb/config/ia64/linux.mh
+++ b/gdb/config/ia64/linux.mh
@@ -3,6 +3,6 @@
 NAT_FILE= nm-linux.h
 NATDEPFILES= inf-ptrace.o fork-child.o corelow.o gcore.o \
 	core-aout.o core-regset.o ia64-linux-nat.o \
-	proc-service.o linux-thread-db.o linux-nat.o
+	proc-service.o linux-thread-db.o linux-nat.o linux-fork.o
 
 LOADLIBES = -ldl -rdynamic
diff --git a/gdb/config/m32r/linux.mh b/gdb/config/m32r/linux.mh
index 0986bab..0f94bd8 100644
--- a/gdb/config/m32r/linux.mh
+++ b/gdb/config/m32r/linux.mh
@@ -3,6 +3,6 @@
 NAT_FILE= nm-linux.h
 NATDEPFILES= inf-ptrace.o fork-child.o corelow.o	\
 	m32r-linux-nat.o gcore.o proc-service.o linux-thread-db.o	\
-	linux-nat.o
+	linux-nat.o linux-fork.o
 
 LOADLIBES= -ldl -rdynamic
diff --git a/gdb/config/m68k/linux.mh b/gdb/config/m68k/linux.mh
index e867396..871632d 100644
--- a/gdb/config/m68k/linux.mh
+++ b/gdb/config/m68k/linux.mh
@@ -3,7 +3,7 @@
 NAT_FILE= nm-linux.h
 NATDEPFILES= inf-ptrace.o fork-child.o \
 	corelow.o core-aout.o m68klinux-nat.o gcore.o \
-	proc-service.o linux-thread-db.o linux-nat.o
+	proc-service.o linux-thread-db.o linux-nat.o linux-fork.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 56f4f9c..4f5e01f 100644
--- a/gdb/config/mips/linux.mh
+++ b/gdb/config/mips/linux.mh
@@ -2,6 +2,6 @@
 NAT_FILE= nm-linux.h
 NATDEPFILES= inf-ptrace.o fork-child.o mips-linux-nat.o \
 	linux-thread-db.o proc-service.o gcore.o \
-	linux-nat.o
+	linux-nat.o linux-fork.o
 
 LOADLIBES = -ldl -rdynamic
diff --git a/gdb/config/pa/linux.mh b/gdb/config/pa/linux.mh
index 59b4c58..b0362e4 100644
--- a/gdb/config/pa/linux.mh
+++ b/gdb/config/pa/linux.mh
@@ -3,6 +3,6 @@ XDEPFILES=
 NAT_FILE= nm-linux.h
 NATDEPFILES= inf-ptrace.o fork-child.o corelow.o gcore.o \
 	core-regset.o hppa-linux-nat.o \
-	proc-service.o linux-thread-db.o linux-nat.o
+	proc-service.o linux-thread-db.o linux-nat.o linux-fork.o
 
 LOADLIBES = -ldl -rdynamic
diff --git a/gdb/config/powerpc/linux.mh b/gdb/config/powerpc/linux.mh
index 8b3cbbb..9a6a2a4 100644
--- a/gdb/config/powerpc/linux.mh
+++ b/gdb/config/powerpc/linux.mh
@@ -5,6 +5,6 @@ XM_CLIBS=
 NAT_FILE= nm-linux.h
 NATDEPFILES= inf-ptrace.o fork-child.o \
 	ppc-linux-nat.o proc-service.o linux-thread-db.o \
-	gcore.o linux-nat.o
+	gcore.o linux-nat.o linux-fork.o
 
 LOADLIBES = -ldl -rdynamic
diff --git a/gdb/config/powerpc/ppc64-linux.mh b/gdb/config/powerpc/ppc64-linux.mh
index 0a4a4ab..6cee590 100644
--- a/gdb/config/powerpc/ppc64-linux.mh
+++ b/gdb/config/powerpc/ppc64-linux.mh
@@ -5,7 +5,7 @@ XM_CLIBS=
 NAT_FILE= nm-ppc64-linux.h
 NATDEPFILES= inf-ptrace.o fork-child.o \
 	ppc-linux-nat.o proc-service.o linux-thread-db.o \
-	gcore.o linux-nat.o
+	gcore.o linux-nat.o linux-fork.o
 
 # The PowerPC has severe limitations on TOC size, and uses them even
 # for non-PIC code.  GDB overflows those tables when compiling with
diff --git a/gdb/config/sparc/linux.mh b/gdb/config/sparc/linux.mh
index bc52fb7..0494381 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 sparc-linux-nat.o \
 	corelow.o core-regset.o fork-child.o inf-ptrace.o \
 	proc-service.o linux-thread-db.o \
-	gcore.o linux-nat.o
+	gcore.o linux-nat.o linux-fork.o
 
 # The dynamically loaded libthread_db needs access to symbols in the
 # gdb executable.
diff --git a/gdb/config/sparc/linux64.mh b/gdb/config/sparc/linux64.mh
index 26514cf..59dfbf0 100644
--- a/gdb/config/sparc/linux64.mh
+++ b/gdb/config/sparc/linux64.mh
@@ -4,7 +4,7 @@ NATDEPFILES= sparc-nat.o sparc64-nat.o sparc-sol2-nat.o sparc64-linux-nat.o \
 	corelow.o core-regset.o \
 	fork-child.o inf-ptrace.o \
 	proc-service.o linux-thread-db.o \
-	gcore.o linux-nat.o
+	gcore.o linux-nat.o linux-fork.o
 
 # The dynamically loaded libthread_db needs access to symbols in the
 # gdb executable.
diff --git a/gdb/infrun.c b/gdb/infrun.c
index 84c920f..47fbe09 100644
--- a/gdb/infrun.c
+++ b/gdb/infrun.c
@@ -1102,6 +1102,12 @@ get_last_target_status (ptid_t *ptidp, struct target_waitstatus *status)
   *status = target_last_waitstatus;
 }
 
+void
+nullify_last_target_wait_ptid (void)
+{
+  target_last_wait_ptid = minus_one_ptid;
+}
+
 /* Switch thread contexts, maintaining "infrun state". */
 
 static void
diff --git a/gdb/linux-fork.c b/gdb/linux-fork.c
new file mode 100644
index 0000000..46b0d90
--- /dev/null
+++ b/gdb/linux-fork.c
@@ -0,0 +1,689 @@
+/* GNU/Linux native-dependent code for debugging multiple forks.
+
+   Copyright (C) 2005 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., 51 Franklin Street, Fifth Floor,
+   Boston, MA 02110-1301, USA.  */
+
+#include "defs.h"
+#include "inferior.h"
+#include "regcache.h"
+#include "gdbcmd.h"
+#include "infcall.h"
+#include "gdb_string.h"
+#include "linux-fork.h"
+
+#include <sys/ptrace.h>
+#include <sys/wait.h>
+#include <sys/param.h>
+#include <dirent.h>
+#include <ctype.h>
+
+struct fork_info *fork_list;
+static int highest_fork_num;
+
+/* Prevent warning from -Wmissing-prototypes.  */
+extern void _initialize_linux_fork (void);
+
+int detach_fork = 1;		/* Default behavior is to detach
+				   newly forked processes (legacy).  */
+
+/* Fork list data structure:  */
+struct fork_info
+{
+  struct fork_info *next;
+  ptid_t ptid;
+  int num;			/* Convenient handle (GDB fork id) */
+  struct regcache *savedregs;	/* Convenient for info fork, saves 
+				   having to actually switch contexts.  */
+  int clobber_regs;		/* True if we should restore saved regs.  */
+  ULONGEST pc;			/* PC for info fork.  */
+  off_t *filepos;		/* Set of open file descriptors' offsets.  */
+  int maxfd;
+};
+
+/* Fork list methods:  */
+
+extern int
+forks_exist_p (void)
+{
+  return (fork_list != NULL);
+}
+
+/* Add a fork to internal fork list.
+   Called from linux child_follow_fork.  */
+
+extern struct fork_info *
+add_fork (pid_t pid)
+{
+  struct fork_info *fp;
+
+  if (fork_list == NULL &&
+      pid != PIDGET (inferior_ptid))
+    {
+      /* Special case -- if this is the first fork in the list
+	 (the list is hitherto empty), and if this new fork is
+	 NOT the current inferior_ptid, then add inferior_ptid
+	 first, as a special zeroeth fork id.  */
+      highest_fork_num = -1;
+      add_fork (PIDGET (inferior_ptid));	/* safe recursion */
+    }
+
+  fp = XZALLOC (struct fork_info);
+  fp->ptid = pid_to_ptid (pid);
+  fp->num = ++highest_fork_num;
+  fp->next = fork_list;
+  fork_list = fp;
+  return fp;
+}
+
+static void
+free_fork (struct fork_info *fp)
+{
+  /* Notes on step-resume breakpoints: since this is a concern for
+     threads, let's convince ourselves that it's not a concern for
+     forks.  There are two ways for a fork_info to be created.  First,
+     by the checkpoint command, in which case we're at a gdb prompt
+     and there can't be any step-resume breakpoint.  Second, by a fork
+     in the user program, in which case we *may* have stepped into the
+     fork call, but regardless of whether we follow the parent or the
+     child, we will return to the same place and the step-resume
+     breakpoint, if any, will take care of itself as usual.  And
+     unlike threads, we do not save a private copy of the step-resume
+     breakpoint -- so we're OK.  */
+
+  if (fp)
+    {
+      if (fp->savedregs)
+	regcache_xfree (fp->savedregs);
+      if (fp->filepos)
+	xfree (fp->filepos);
+      xfree (fp);
+    }
+}
+
+static void
+delete_fork (ptid_t ptid)
+{
+  struct fork_info *fp, *fpprev;
+
+  fpprev = NULL;
+
+  for (fp = fork_list; fp; fpprev = fp, fp = fp->next)
+    if (ptid_equal (fp->ptid, ptid))
+      break;
+
+  if (!fp)
+    return;
+
+  if (fpprev)
+    fpprev->next = fp->next;
+  else
+    fork_list = fp->next;
+
+  free_fork (fp);
+
+  /* Special case: if there is now only one process in the list, 
+     and if it is (hopefully!) the current inferior_ptid, then
+     remove it, leaving the list empty -- we're now down to the
+     default case of debugging a single process.  */
+  if (fork_list != NULL && fork_list->next == NULL &&
+      ptid_equal (fork_list->ptid, inferior_ptid))
+    {
+      /* Last fork -- delete from list and handle as solo process
+	 (should be a safe recursion).  */
+      delete_fork (inferior_ptid);
+    }
+}
+
+/* Find a fork_info by matching PTID.  */
+static struct fork_info *
+find_fork_ptid (ptid_t ptid)
+{
+  struct fork_info *fp;
+
+  for (fp = fork_list; fp; fp = fp->next)
+    if (ptid_equal (fp->ptid, ptid))
+      return fp;
+
+  return NULL;
+}
+
+/* Find a fork_info by matching ID.  */
+static struct fork_info *
+find_fork_id (int num)
+{
+  struct fork_info *fp;
+
+  for (fp = fork_list; fp; fp = fp->next)
+    if (fp->num == num)
+      return fp;
+
+  return NULL;
+}
+
+/* Find a fork_info by matching pid.  */
+extern struct fork_info *
+find_fork_pid (pid_t pid)
+{
+  struct fork_info *fp;
+
+  for (fp = fork_list; fp; fp = fp->next)
+    if (pid == ptid_get_pid (fp->ptid))
+      return fp;
+
+  return NULL;
+}
+
+static ptid_t
+fork_id_to_ptid (int num)
+{
+  struct fork_info *fork = find_fork_id (num);
+  if (fork)
+    return fork->ptid;
+  else
+    return pid_to_ptid (-1);
+}
+
+static void
+init_fork_list (void)
+{
+  struct fork_info *fp, *fpnext;
+
+  if (!fork_list)
+    return;
+
+  for (fp = fork_list; fp; fp = fpnext)
+    {
+      fpnext = fp->next;
+      free_fork (fp);
+    }
+
+  fork_list = NULL;
+}
+
+/* Fork list <-> gdb interface.  */
+
+/* Utility function for fork_load/fork_save.  
+   Calls lseek in the (current) inferior process.  */
+
+static off_t
+call_lseek (int fd, off_t offset, int whence)
+{
+  char exp[80];
+
+  snprintf (&exp[0], sizeof (exp), "lseek (%d, %ld, %d)",
+	    fd, (long) offset, whence);
+  return (off_t) parse_and_eval_long (&exp[0]);
+}
+
+/* Load infrun state for the fork PTID.  */
+
+static void
+fork_load_infrun_state (struct fork_info *fp)
+{
+  extern void nullify_last_target_wait_ptid ();
+  int i;
+
+  if (fp->savedregs && fp->clobber_regs)
+    regcache_cpy (current_regcache, fp->savedregs);
+
+  nullify_last_target_wait_ptid ();
+
+  /* Now restore the file positions of open file descriptors.  */
+  if (fp->filepos)
+    {
+      for (i = 0; i <= fp->maxfd; i++)
+	if (fp->filepos[i] != (off_t) -1)
+	  call_lseek (i, fp->filepos[i], SEEK_SET);
+      /* NOTE: I can get away with using SEEK_SET and SEEK_CUR because
+	 this is native-only.  If it ever has to be cross, we'll have
+	 to rethink this.  */
+    }
+}
+
+/* Save infrun state for the fork PTID.
+   Exported for use by linux child_follow_fork.  */
+
+extern void
+fork_save_infrun_state (struct fork_info *fp, int clobber_regs)
+{
+  char path[MAXPATHLEN];
+  struct dirent *de;
+  DIR *d;
+
+  if (fp->savedregs)
+    regcache_xfree (fp->savedregs);
+
+  fp->savedregs = regcache_dup (current_regcache);
+  fp->clobber_regs = clobber_regs;
+  fp->pc = read_pc ();
+
+  if (clobber_regs)
+    {
+      /* Now save the 'state' (file position) of all open file descriptors.
+	 Unfortunately fork does not take care of that for us...  */
+      snprintf (path, MAXPATHLEN, "/proc/%ld/fd", (long) PIDGET (fp->ptid));
+      if ((d = opendir (path)) != NULL)
+	{
+	  long tmp;
+
+	  fp->maxfd = 0;
+	  while ((de = readdir (d)) != NULL)
+	    {
+	      /* Count open file descriptors (actually find highest
+		 numbered).  */
+	      tmp = strtol (&de->d_name[0], NULL, 10);
+	      if (fp->maxfd < tmp)
+		fp->maxfd = tmp;
+	    }
+	  /* Allocate array of file positions.  */
+	  fp->filepos = xrealloc (fp->filepos, 
+				  (fp->maxfd + 1) * sizeof (*fp->filepos));
+
+	  /* Initialize to -1 (invalid).  */
+	  for (tmp = 0; tmp <= fp->maxfd; tmp++)
+	    fp->filepos[tmp] = -1;
+
+	  /* Now find actual file positions.  */
+	  rewinddir (d);
+	  while ((de = readdir (d)) != NULL)
+	    if (isdigit (de->d_name[0]))
+	      {
+		tmp = strtol (&de->d_name[0], NULL, 10);
+		fp->filepos[tmp] = call_lseek (tmp, 0, SEEK_CUR);
+	      }
+	  closedir (d);
+	}
+    }
+}
+
+/* Kill 'em all, let God sort 'em out...  */
+
+extern void
+linux_fork_killall (void)
+{
+  /* Walk list and kill every pid.  No need to treat the
+     current inferior_ptid as special (we do not return a
+     status for it) -- however any process may be a child
+     or a parent, so may get a SIGCHLD from a previously
+     killed child.  Wait them all out.  */
+  pid_t pid, ret;
+  int status;
+
+  do {
+    pid = PIDGET (fork_list->ptid);
+    do {
+      ptrace (PT_KILL, pid, 0, 0);
+      ret = waitpid (pid, &status, 0);
+    } while (ret == pid && WIFSTOPPED (status));
+    delete_fork (fork_list->ptid);
+  } while (fork_list != NULL);
+}
+
+/* The current inferior_ptid has exited, but there are other viable
+   forks to debug.  Delete the exiting one and context-switch to the
+   first available.  */
+
+extern void
+linux_fork_mourn_inferior (void)
+{
+  /* Wait just one more time to collect the inferior's exit status.
+     Do not check whether this succeeds though, since we may be
+     dealing with a process that we attached to.  Such a process will
+     only report its exit status to its original parent.  */
+  int status;
+
+  waitpid (ptid_get_pid (inferior_ptid), &status, 0);
+
+  /* OK, presumably inferior_ptid is the one who has exited.
+     We need to delete that one from the fork_list, and switch
+     to the next available fork.  */
+  delete_fork (inferior_ptid);
+  if (fork_list)	/* Paranoia, shouldn't happen.  */
+    {
+      inferior_ptid = fork_list[0].ptid;
+      printf_filtered (_("[Switching to %s]\n"), 
+		       target_pid_to_str (inferior_ptid));
+    }
+}
+
+/* Fork list <-> user interface.  */
+
+static void
+delete_fork_command (char *args, int from_tty)
+{
+  ptid_t ptid;
+
+  if (!args || !*args)
+    error (_("Requires argument (fork/checkpoint id to delete)"));
+
+  ptid = fork_id_to_ptid (parse_and_eval_long (args));
+  if (ptid_equal (ptid, minus_one_ptid))
+    error (_("No such fork/checkpoint id, %s"), args);
+
+  if (ptid_equal (ptid, inferior_ptid))
+    error (_("Please switch to another fork/checkpoint before deleting the current one"));
+
+  if (ptrace (PTRACE_KILL, ptid, 0, 0))
+    error (_("Unable to kill pid %s"), target_tid_to_str (ptid));
+
+  if (from_tty)
+    printf_filtered (_("Killed %s\n"), target_pid_to_str (ptid));
+
+  delete_fork (ptid);
+}
+
+static void
+detach_fork_command (char *args, int from_tty)
+{
+  ptid_t ptid;
+
+  if (!args || !*args)
+    error (_("Requires argument (fork id to detach)"));
+
+  ptid = fork_id_to_ptid (parse_and_eval_long (args));
+  if (ptid_equal (ptid, minus_one_ptid))
+    error (_("No such fork id, %s"), args);
+
+  if (ptid_equal (ptid, inferior_ptid))
+    error (_("Please switch to another fork before detaching the current one"));
+
+  if (ptrace (PTRACE_DETACH, ptid, 0, 0))
+    error (_("Unable to detach %s"), target_pid_to_str (ptid));
+
+  if (from_tty)
+    printf_filtered (_("Detached %s\n"), target_pid_to_str (ptid));
+
+  delete_fork (ptid);
+}
+
+/* Print information about currently known forks.  */
+
+static void
+info_forks_command (char *arg, int from_tty)
+{
+  struct frame_info *cur_frame;
+  struct symtab_and_line sal;
+  struct symtab *cur_symtab;
+  struct fork_info *fp;
+  int cur_line;
+  ULONGEST pc;
+
+  for (fp = fork_list; fp; fp = fp->next)
+    {
+      if (ptid_equal (fp->ptid, inferior_ptid))
+	{
+	  printf_filtered ("* ");
+	  pc = read_pc ();
+	}
+      else
+	{
+	  printf_filtered ("  ");
+	  pc = fp->pc;
+	}
+      printf_filtered ("%d %s", fp->num, target_pid_to_str (fp->ptid));
+      if (fp->num == 0)
+	printf_filtered (_(" (main process)"));
+      printf_filtered (_(" at "));
+      deprecated_print_address_numeric (pc, 1, gdb_stdout);
+
+      sal = find_pc_line (pc, 0);
+      if (sal.symtab)
+	{
+	  char *tmp = strrchr (sal.symtab->filename, '/');
+
+	  if (tmp)
+	    printf_filtered (_(", file %s"), tmp + 1);
+	  else
+	    printf_filtered (_(", file %s"), sal.symtab->filename);
+	}
+      if (sal.line)
+	printf_filtered (_(", line %d"), sal.line);
+      if (!sal.symtab && !sal.line)
+	{
+	  struct minimal_symbol *msym;
+
+	  msym = lookup_minimal_symbol_by_pc (pc);
+	  if (msym)
+	    printf_filtered (", <%s>", SYMBOL_LINKAGE_NAME (msym));
+	}
+
+      putchar_filtered ('\n');
+    }
+}
+
+/* Save/restore mode variable 'detach_fork':
+   We need to temporarily take over this mode variable, while
+   preserving the user-specified state, and make sure that it 
+   gets restored in case of error.
+
+   The int pointer that we use comes from the caller, so we can
+   be called more than once (even though currently we don't need to).  */
+
+static void 
+restore_detach_fork (void *arg)
+{
+  detach_fork = *(int *) arg;
+}
+
+static struct cleanup *
+save_detach_fork (int *saved_val)
+{
+  *saved_val = detach_fork;
+  return make_cleanup (restore_detach_fork, (void *) saved_val);
+}
+
+static void
+checkpoint_command (char *args, int from_tty)
+{
+  struct target_waitstatus last_target_waitstatus;
+  ptid_t last_target_ptid;
+  struct value *fork_fn = NULL, *ret;
+  struct fork_info *fp;
+  pid_t retpid;
+  struct cleanup *old_chain;
+  long i;
+  /* Make this temp var static, 'cause it's used in the error context.  */
+  static int temp_detach_fork;
+
+  /* Make the inferior fork, record its (and gdb's) state.  */
+
+  if (lookup_minimal_symbol ("fork", NULL, NULL) != NULL)
+    fork_fn = find_function_in_inferior ("fork");
+  if (!fork_fn)
+    if (lookup_minimal_symbol ("_fork", NULL, NULL) != NULL)
+      fork_fn = find_function_in_inferior ("fork");
+  if (!fork_fn)
+    error (_("checkpoint: can't find fork function in inferior."));
+
+  ret = value_from_longest (builtin_type_int, 0);
+  old_chain = save_detach_fork (&temp_detach_fork);
+  detach_fork = 0;
+  ret = call_function_by_hand (fork_fn, 0, &ret);
+  do_cleanups (old_chain);
+  if (!ret)	/* Probably can't happen.  */
+    error (_("checkpoint: call_function_by_hand returned null."));
+
+  retpid = value_as_long (ret);
+  get_last_target_status (&last_target_ptid, &last_target_waitstatus);
+  if (from_tty)
+    {
+      int parent_pid;
+
+      printf_filtered (_("checkpoint: fork returned pid %ld.\n"), 
+		       (long) retpid);
+      if (info_verbose)
+	{
+	  parent_pid = ptid_get_lwp (last_target_ptid);
+	  if (parent_pid == 0)
+	    parent_pid = ptid_get_pid (last_target_ptid);
+	  printf_filtered (_("   gdb says parent = %ld.\n"), 
+			   (long) parent_pid);
+	}
+    }
+
+  fp = find_fork_pid (retpid);
+  if (!fp)
+    error (_("Failed to find new fork"));
+  fork_save_infrun_state (fp, 1);
+}
+
+static void
+linux_fork_context (struct fork_info *newfp, int from_tty)
+{
+  /* Now we attempt to switch processes.  */
+  struct fork_info *oldfp = find_fork_ptid (inferior_ptid);
+  ptid_t ptid;
+  int id, i;
+
+  if (!newfp)
+    error (_("No such fork/process"));
+
+  if (!oldfp)
+    {
+      oldfp = add_fork (ptid_get_pid (inferior_ptid));
+    }
+
+  fork_save_infrun_state (oldfp, 1);
+  inferior_ptid = newfp->ptid;
+  fork_load_infrun_state (newfp);
+  registers_changed ();
+  reinit_frame_cache ();
+  stop_pc = read_pc ();
+  select_frame (get_current_frame ());
+
+  printf_filtered (_("Switching to %s\n"), 
+		   target_pid_to_str (inferior_ptid));
+
+  print_stack_frame (get_selected_frame (NULL), 1, SRC_AND_LOC);
+}
+
+/* Switch inferior process (fork) context, by process id.  */
+static void
+process_command (char *args, int from_tty)
+{
+  struct fork_info *fp;
+
+  if (!args || !*args)
+    error (_("Requires argument (process id to switch to)"));
+
+  if ((fp = find_fork_pid (parse_and_eval_long (args))) == NULL)
+    error (_("Not found: process id %s"), args);
+
+  linux_fork_context (fp, from_tty);
+}
+
+/* Switch inferior process (fork) context, by fork id.  */
+static void
+fork_command (char *args, int from_tty)
+{
+  struct fork_info *fp;
+
+  if (!args || !*args)
+    error (_("Requires argument (fork id to switch to)"));
+
+  if ((fp = find_fork_id (parse_and_eval_long (args))) == NULL)
+    error (_("Not found: fork id %s"), args);
+
+  linux_fork_context (fp, from_tty);
+}
+
+/* Switch inferior process (fork) context, by checkpoint id.  */
+static void
+restart_command (char *args, int from_tty)
+{
+  struct fork_info *fp;
+
+  if (!args || !*args)
+    error (_("Requires argument (checkpoint id to restart)"));
+
+  if ((fp = find_fork_id (parse_and_eval_long (args))) == NULL)
+    error (_("Not found: checkpoint id %s"), args);
+
+  linux_fork_context (fp, from_tty);
+}
+
+void
+_initialize_linux_fork (void)
+{
+  init_fork_list ();
+
+  /* Set/show detach-on-fork: user-settable mode.  */
+
+  add_setshow_boolean_cmd ("detach-on-fork", class_obscure, &detach_fork, _("\
+Set whether gdb will detach the child of a fork."), _("\
+Show whether gdb will detach the child of a fork."), _("\
+Tells gdb whether to detach the child of a fork."), 
+			   NULL, NULL, &setlist, &showlist);
+
+  /* Set/show restart-auto-finish: user-settable count.  Causes the
+     first "restart" of a fork to do some number of "finish" commands
+     before returning to user.
+
+     Useful because otherwise the virgin fork process will be stopped
+     somewhere in the un-interesting fork system call.  */
+
+  /* Checkpoint command: create a fork of the inferior process
+     and set it aside for later debugging.  */
+
+  add_com ("checkpoint", class_obscure, checkpoint_command, _("\
+Fork a duplicate process (experimental)."));
+
+  /* Restart command: restore the context of a specified fork
+     process.  May be used for "program forks" as well as for
+     "debugger forks" (checkpoints).  */
+
+  add_com ("restart", class_obscure, restart_command, _("\
+restart <n>: restore program context from a checkpoint.\n\
+Argument 'n' is checkpoint ID, as displayed by 'info checkpoints'."));
+
+  /* Delete-checkpoint command: kill the process and remove it from
+     fork list.  */
+
+  add_com ("delete-checkpoint", class_obscure, delete_fork_command, _("\
+Delete a fork/checkpoint (experimental)."));
+
+  /* Detach-checkpoint command: release the process to run independantly, 
+     and remove it from the fork list.  */
+
+  add_com ("detach-checkpoint", class_obscure, detach_fork_command, _("\
+Detach from a fork/checkpoint (experimental)."));
+
+  /* Info checkpoints command: list all forks/checkpoints 
+     currently under gdb's control.  */
+
+  add_info ("checkpoints", info_forks_command,
+	    _("IDs of currently known forks/checkpoints."));
+
+  /* Command aliases (let "fork" and "checkpoint" be used 
+     interchangeably).  */
+
+  add_com_alias ("delete-fork", "delete-checkpoint", class_obscure, 1);
+  add_com_alias ("detach-fork", "detach-checkpoint", class_obscure, 1);
+  add_info_alias ("forks", "checkpoints", 0);
+
+  /* "fork <n>" (by analogy to "thread <n>").  */
+  add_com ("fork", class_obscure, fork_command, _("\
+fork <n>: Switch between forked processes.\n\
+Argument 'n' is fork ID, as displayed by 'info forks'."));
+
+  /* "process <proc id>" as opposed to "fork <fork id>".  */
+  add_com ("process", class_obscure, process_command, _("\
+process <pid>: Switch between forked processes.\n\
+Argument 'pid' is process ID, as displayed by 'info forks' or 'shell ps'."));
+}
diff --git a/gdb/linux-fork.h b/gdb/linux-fork.h
new file mode 100644
index 0000000..9b15403
--- /dev/null
+++ b/gdb/linux-fork.h
@@ -0,0 +1,33 @@
+/* GNU/Linux native-dependent code for debugging multiple forks.
+
+   Copyright 2005 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.  */
+
+struct fork_info;
+extern struct fork_info *add_fork (pid_t);
+extern struct fork_info *find_fork_pid (pid_t);
+extern void fork_save_infrun_state (struct fork_info *, int);
+extern void linux_fork_killall (void);
+extern void linux_fork_mourn_inferior (void);
+extern int  forks_exist_p (void);
+
+struct fork_info *fork_list;
+
+extern int detach_fork;
+
diff --git a/gdb/linux-nat.c b/gdb/linux-nat.c
index 786e549..7b4bed8 100644
--- a/gdb/linux-nat.c
+++ b/gdb/linux-nat.c
@@ -31,6 +31,7 @@
 #endif
 #include <sys/ptrace.h>
 #include "linux-nat.h"
+#include "linux-fork.h"
 #include "gdbthread.h"
 #include "gdbcmd.h"
 #include "regcache.h"
@@ -87,12 +88,18 @@
    the use of the multi-threaded target.  */
 static struct target_ops *linux_ops;
 
-/* The saved to_xfer_partial method, inherited from inf-ptrace.c.  Called
-   by our to_xfer_partial.   */
-static LONGEST (*super_xfer_partial) (struct target_ops *, enum target_object,
-				      const char *, gdb_byte *, const gdb_byte *,
+/* The saved to_xfer_partial method, inherited from inf-ptrace.c.
+   Called by our to_xfer_partial.  */
+static LONGEST (*super_xfer_partial) (struct target_ops *, 
+				      enum target_object,
+				      const char *, gdb_byte *, 
+				      const gdb_byte *,
 				      ULONGEST, LONGEST);
 
+/* The saved to_mourn_inferior method, inherited from inf-ptrace.c.
+   Called by our to_mourn_inferior.  */
+static void (*super_mourn_inferior) (void);
+
 static int debug_linux_nat;
 static void
 show_debug_linux_nat (struct ui_file *file, int from_tty,
@@ -363,15 +370,28 @@ child_follow_fork (struct target_ops *ops, int follow_child)
 	 also, but they'll be reinserted below.  */
       detach_breakpoints (child_pid);
 
-      if (debug_linux_nat)
+      /* Detach new forked process?  */
+      if (detach_fork)
 	{
-	  target_terminal_ours ();
-	  fprintf_unfiltered (gdb_stdlog,
-			      "Detaching after fork from child process %d.\n",
-			      child_pid);
-	}
+	  if (debug_linux_nat)
+	    {
+	      target_terminal_ours ();
+	      fprintf_filtered (gdb_stdlog,
+				"Detaching after fork from child process %d.\n",
+				child_pid);
+	    }
 
-      ptrace (PTRACE_DETACH, child_pid, 0, 0);
+	  ptrace (PTRACE_DETACH, child_pid, 0, 0);
+	}
+      else
+	{
+	  struct fork_info *fp;
+	  /* Retain child fork in ptrace (stopped) state.  */
+	  fp = find_fork_pid (child_pid);
+	  if (!fp)
+	    fp = add_fork (child_pid);
+	  fork_save_infrun_state (fp, 0);
+	}
 
       if (has_vforked)
 	{
@@ -441,9 +461,9 @@ child_follow_fork (struct target_ops *ops, int follow_child)
       if (debug_linux_nat)
 	{
 	  target_terminal_ours ();
-	  fprintf_unfiltered (gdb_stdlog,
-			      "Attaching after fork to child process %d.\n",
-			      child_pid);
+	  fprintf_filtered (gdb_stdlog,
+			    "Attaching after fork to child process %d.\n",
+			    child_pid);
 	}
 
       /* If we're vforking, we may want to hold on to the parent until
@@ -466,13 +486,25 @@ child_follow_fork (struct target_ops *ops, int follow_child)
 
       if (has_vforked)
 	linux_parent_pid = parent_pid;
+      else if (!detach_fork)
+	{
+	  struct fork_info *fp;
+	  /* Retain parent fork in ptrace (stopped) state.  */
+	  fp = find_fork_pid (parent_pid);
+	  if (!fp)
+	    fp = add_fork (parent_pid);
+	  fork_save_infrun_state (fp, 0);
+	}
       else
-	target_detach (NULL, 0);
+	{
+	  target_detach (NULL, 0);
+	}
 
       inferior_ptid = pid_to_ptid (child_pid);
 
       /* Reinstall ourselves, since we might have been removed in
 	 target_detach (which does other necessary cleanup).  */
+
       push_target (ops);
 
       /* Reset breakpoints in the child as appropriate.  */
@@ -579,33 +611,42 @@ kill_inferior (void)
   if (pid == 0)
     return;
 
-  /* If we're stopped while forking and we haven't followed yet, kill the
-     other task.  We need to do this first because the parent will be
-     sleeping if this is a vfork.  */
-
-  get_last_target_status (&last_ptid, &last);
-
-  if (last.kind == TARGET_WAITKIND_FORKED
-      || last.kind == TARGET_WAITKIND_VFORKED)
+  /* First cut -- let's crudely do everything inline.  */
+  if (forks_exist_p ())
     {
-      ptrace (PT_KILL, last.value.related_pid, 0, 0);
-      wait (&status);
+      linux_fork_killall ();
+      pop_target ();
+      generic_mourn_inferior ();
     }
+  else
+    {
+      /* If we're stopped while forking and we haven't followed yet,
+	 kill the other task.  We need to do this first because the
+	 parent will be sleeping if this is a vfork.  */
 
-  /* Kill the current process.  */
-  ptrace (PT_KILL, pid, 0, 0);
-  ret = wait (&status);
+      get_last_target_status (&last_ptid, &last);
 
-  /* We might get a SIGCHLD instead of an exit status.  This is
-     aggravated by the first kill above - a child has just died.  */
+      if (last.kind == TARGET_WAITKIND_FORKED
+	  || last.kind == TARGET_WAITKIND_VFORKED)
+	{
+	  ptrace (PT_KILL, last.value.related_pid, 0, 0);
+	  wait (&status);
+	}
 
-  while (ret == pid && WIFSTOPPED (status))
-    {
+      /* Kill the current process.  */
       ptrace (PT_KILL, pid, 0, 0);
       ret = wait (&status);
-    }
 
-  target_mourn_inferior ();
+      /* We might get a SIGCHLD instead of an exit status.  This is
+	 aggravated by the first kill above - a child has just died.  */
+
+      while (ret == pid && WIFSTOPPED (status))
+	{
+	  ptrace (PT_KILL, pid, 0, 0);
+	  ret = wait (&status);
+	}
+      target_mourn_inferior ();
+    }
 }
 
 /* On GNU/Linux there are no real LWP's.  The closest thing to LWP's
@@ -1677,7 +1718,7 @@ select_event_lwp (struct lwp_info **orig_lp, int *status)
   int random_selector;
   struct lwp_info *event_lp;
 
-  /* Record the wait status for the origional LWP.  */
+  /* Record the wait status for the original LWP.  */
   (*orig_lp)->status = *status;
 
   /* Give preference to any LWP that is being single-stepped.  */
@@ -1729,6 +1770,30 @@ resumed_callback (struct lwp_info *lp, void *data)
   return lp->resumed;
 }
 
+/* Local mourn_inferior -- we need to override mourn_inferior
+   so that we can do something clever if one of several forks
+   has exited.  */
+
+static void
+child_mourn_inferior (void)
+{
+  int status;
+
+  if (! forks_exist_p ())
+    {
+      /* Normal case, no other forks available.  */
+      super_mourn_inferior ();
+      return;
+    }
+  else
+    {
+      /* Multi-fork case.  The current inferior_ptid has exited, but
+	 there are other viable forks to debug.  Delete the exiting
+	 one and context-switch to the first available.  */
+      linux_fork_mourn_inferior ();
+    }
+}
+
 /* 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.  */
@@ -3201,6 +3266,9 @@ linux_target (void)
   super_xfer_partial = t->to_xfer_partial;
   t->to_xfer_partial = linux_xfer_partial;
 
+  super_mourn_inferior = t->to_mourn_inferior;
+  t->to_mourn_inferior = child_mourn_inferior;
+
   linux_ops = t;
   return t;
 }
@@ -3312,3 +3380,4 @@ lin_thread_get_thread_signals (sigset_t *set)
   /* ... except during a sigsuspend.  */
   sigdelset (&suspend_mask, cancel);
 }
+