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.

1 files changed, 689 insertions, 0 deletions

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'."));
+}