X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=gdb%2Flinux-fork.c;h=b1b390c5c6e0dc52e9b516bf22f59e219667ea46;hb=e9224f6d80ea35e90a61d44575f12b26742eaaf3;hp=83d92fe9c7970b7c8f4252493cc943f89eb17ee7;hpb=cdf430071a9b0a75ba633b7623e47df73c1b8463;p=external%2Fbinutils.git

diff --git a/gdb/linux-fork.c b/gdb/linux-fork.c
index 83d92fe..b1b390c 100644
--- a/gdb/linux-fork.c
+++ b/gdb/linux-fork.c
@@ -1,6 +1,6 @@
 /* GNU/Linux native-dependent code for debugging multiple forks.
 
-   Copyright (C) 2005, 2006, 2007 Free Software Foundation, Inc.
+   Copyright (C) 2005-2019 Free Software Foundation, Inc.
 
    This file is part of GDB.
 
@@ -18,75 +18,94 @@
    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
 
 #include "defs.h"
+#include "arch-utils.h"
 #include "inferior.h"
+#include "infrun.h"
 #include "regcache.h"
 #include "gdbcmd.h"
 #include "infcall.h"
-#include "gdb_assert.h"
-#include "gdb_string.h"
+#include "objfiles.h"
 #include "linux-fork.h"
 #include "linux-nat.h"
-#include "gdb_wait.h"
+#include "gdbthread.h"
+#include "source.h"
 
-#include <sys/ptrace.h>
-#include <sys/param.h>
+#include "nat/gdb_ptrace.h"
+#include "common/gdb_wait.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 
+  ptid_t parent_ptid;
+  int num;			/* Convenient handle (GDB fork id).  */
+  readonly_detached_regcache *savedregs;	/* Convenient for info fork, saves
 				   having to actually switch contexts.  */
+  CORE_ADDR pc;
   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
+int
 forks_exist_p (void)
 {
   return (fork_list != NULL);
 }
 
-/* Add a fork to internal fork list.
-   Called from linux child_follow_fork.  */
+/* Return the last fork in the list.  */
 
-extern struct fork_info *
+static struct fork_info *
+find_last_fork (void)
+{
+  struct fork_info *last;
+
+  if (fork_list == NULL)
+    return NULL;
+
+  for (last = fork_list; last->next != NULL; last = last->next)
+    ;
+  return last;
+}
+
+/* Add a fork to the internal fork list.  */
+
+struct fork_info *
 add_fork (pid_t pid)
 {
   struct fork_info *fp;
 
-  if (fork_list == NULL && pid != PIDGET (inferior_ptid))
+  if (fork_list == NULL && pid != inferior_ptid.pid ())
     {
       /* 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 */
+      add_fork (inferior_ptid.pid ());	/* safe recursion */
     }
 
-  fp = XZALLOC (struct fork_info);
-  fp->ptid = ptid_build (pid, pid, 0);
+  fp = XCNEW (struct fork_info);
+  fp->ptid = ptid_t (pid, pid, 0);
   fp->num = ++highest_fork_num;
-  fp->next = fork_list;
-  fork_list = fp;
+
+  if (fork_list == NULL)
+    fork_list = fp;
+  else
+    {
+      struct fork_info *last = find_last_fork ();
+
+      last->next = fp;
+    }
+
   return fp;
 }
 
@@ -108,7 +127,7 @@ free_fork (struct fork_info *fp)
   if (fp)
     {
       if (fp->savedregs)
-	regcache_xfree (fp->savedregs);
+	delete fp->savedregs;
       if (fp->filepos)
 	xfree (fp->filepos);
       xfree (fp);
@@ -122,8 +141,10 @@ delete_fork (ptid_t ptid)
 
   fpprev = NULL;
 
+  linux_target->low_forget_process (ptid.pid ());
+
   for (fp = fork_list; fp; fpprev = fp, fp = fp->next)
-    if (ptid_equal (fp->ptid, ptid))
+    if (fp->ptid == ptid)
       break;
 
   if (!fp)
@@ -136,12 +157,12 @@ delete_fork (ptid_t ptid)
 
   free_fork (fp);
 
-  /* Special case: if there is now only one process in the list, 
+  /* 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))
+      fork_list->ptid == inferior_ptid)
     {
       /* Last fork -- delete from list and handle as solo process
 	 (should be a safe recursion).  */
@@ -156,7 +177,7 @@ find_fork_ptid (ptid_t ptid)
   struct fork_info *fp;
 
   for (fp = fork_list; fp; fp = fp->next)
-    if (ptid_equal (fp->ptid, ptid))
+    if (fp->ptid == ptid)
       return fp;
 
   return NULL;
@@ -182,7 +203,7 @@ 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))
+    if (pid == fp->ptid.pid ())
       return fp;
 
   return NULL;
@@ -195,7 +216,7 @@ fork_id_to_ptid (int num)
   if (fork)
     return fork->ptid;
   else
-    return pid_to_ptid (-1);
+    return ptid_t (-1);
 }
 
 static void
@@ -217,7 +238,7 @@ init_fork_list (void)
 
 /* Fork list <-> gdb interface.  */
 
-/* Utility function for fork_load/fork_save.  
+/* Utility function for fork_load/fork_save.
    Calls lseek in the (current) inferior process.  */
 
 static off_t
@@ -225,7 +246,7 @@ call_lseek (int fd, off_t offset, int whence)
 {
   char exp[80];
 
-  snprintf (&exp[0], sizeof (exp), "lseek (%d, %ld, %d)",
+  snprintf (&exp[0], sizeof (exp), "(long) lseek (%d, %ld, %d)",
 	    fd, (long) offset, whence);
   return (off_t) parse_and_eval_long (&exp[0]);
 }
@@ -238,17 +259,16 @@ fork_load_infrun_state (struct fork_info *fp)
   extern void nullify_last_target_wait_ptid ();
   int i;
 
-  inferior_ptid = fp->ptid;
-
-  linux_nat_switch_fork (inferior_ptid);
+  linux_nat_switch_fork (fp->ptid);
 
   if (fp->savedregs && fp->clobber_regs)
-    regcache_cpy (get_current_regcache (), fp->savedregs);
+    get_current_regcache ()->restore (fp->savedregs);
 
   registers_changed ();
   reinit_frame_cache ();
 
-  stop_pc = read_pc ();
+  inferior_thread ()->suspend.stop_pc
+    = regcache_read_pc (get_current_regcache ());
   nullify_last_target_wait_ptid ();
 
   /* Now restore the file positions of open file descriptors.  */
@@ -266,25 +286,26 @@ fork_load_infrun_state (struct fork_info *fp)
 /* Save infrun state for the fork PTID.
    Exported for use by linux child_follow_fork.  */
 
-extern void
+static void
 fork_save_infrun_state (struct fork_info *fp, int clobber_regs)
 {
-  char path[MAXPATHLEN];
+  char path[PATH_MAX];
   struct dirent *de;
   DIR *d;
 
   if (fp->savedregs)
-    regcache_xfree (fp->savedregs);
+    delete fp->savedregs;
 
-  fp->savedregs = regcache_dup (get_current_regcache ());
+  fp->savedregs = new readonly_detached_regcache (*get_current_regcache ());
+  fp->pc = regcache_read_pc (get_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));
+      snprintf (path, PATH_MAX, "/proc/%ld/fd",
+		(long) fp->ptid.pid ());
       if ((d = opendir (path)) != NULL)
 	{
 	  long tmp;
@@ -299,8 +320,7 @@ fork_save_infrun_state (struct fork_info *fp, int clobber_regs)
 		fp->maxfd = tmp;
 	    }
 	  /* Allocate array of file positions.  */
-	  fp->filepos = xrealloc (fp->filepos, 
-				  (fp->maxfd + 1) * sizeof (*fp->filepos));
+	  fp->filepos = XRESIZEVEC (off_t, fp->filepos, fp->maxfd + 1);
 
 	  /* Initialize to -1 (invalid).  */
 	  for (tmp = 0; tmp <= fp->maxfd; tmp++)
@@ -321,7 +341,7 @@ fork_save_infrun_state (struct fork_info *fp, int clobber_regs)
 
 /* Kill 'em all, let God sort 'em out...  */
 
-extern void
+void
 linux_fork_killall (void)
 {
   /* Walk list and kill every pid.  No need to treat the
@@ -335,9 +355,11 @@ linux_fork_killall (void)
 
   for (fp = fork_list; fp; fp = fp->next)
     {
-      pid = PIDGET (fp->ptid);
+      pid = fp->ptid.pid ();
       do {
-	ptrace (PT_KILL, pid, 0, 0);
+	/* Use SIGKILL instead of PTRACE_KILL because the former works even
+	   if the thread is running, while the later doesn't.  */
+	kill (pid, SIGKILL);
 	ret = waitpid (pid, &status, 0);
 	/* We might get a SIGCHLD instead of an exit status.  This is
 	 aggravated by the first kill above - a child has just
@@ -351,16 +373,17 @@ linux_fork_killall (void)
    forks to debug.  Delete the exiting one and context-switch to the
    first available.  */
 
-extern void
+void
 linux_fork_mourn_inferior (void)
 {
+  struct fork_info *last;
+  int status;
+
   /* 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);
+  waitpid (inferior_ptid.pid (), &status, 0);
 
   /* OK, presumably inferior_ptid is the one who has exited.
      We need to delete that one from the fork_list, and switch
@@ -372,7 +395,8 @@ linux_fork_mourn_inferior (void)
      inferior_ptid yet.  */
   gdb_assert (fork_list);
 
-  fork_load_infrun_state (fork_list);
+  last = find_last_fork ();
+  fork_load_infrun_state (last);
   printf_filtered (_("[Switching to %s]\n"),
 		   target_pid_to_str (inferior_ptid));
 
@@ -381,48 +405,192 @@ linux_fork_mourn_inferior (void)
     delete_fork (inferior_ptid);
 }
 
+/* The current inferior_ptid is being detached, but there are other
+   viable forks to debug.  Detach and delete it and context-switch to
+   the first available.  */
+
+void
+linux_fork_detach (int from_tty)
+{
+  /* OK, inferior_ptid is the one we are detaching from.  We need to
+     delete it from the fork_list, and switch to the next available
+     fork.  */
+
+  if (ptrace (PTRACE_DETACH, inferior_ptid.pid (), 0, 0))
+    error (_("Unable to detach %s"), target_pid_to_str (inferior_ptid));
+
+  delete_fork (inferior_ptid);
+
+  /* There should still be a fork - if there's only one left,
+     delete_fork won't remove it, because we haven't updated
+     inferior_ptid yet.  */
+  gdb_assert (fork_list);
+
+  fork_load_infrun_state (fork_list);
+
+  if (from_tty)
+    printf_filtered (_("[Switching to %s]\n"),
+		     target_pid_to_str (inferior_ptid));
+
+  /* If there's only one fork, switch back to non-fork mode.  */
+  if (fork_list->next == NULL)
+    delete_fork (inferior_ptid);
+}
+
+/* Temporarily switch to the infrun state stored on the fork_info
+   identified by a given ptid_t.  When this object goes out of scope,
+   restore the currently selected infrun state.   */
+
+class scoped_switch_fork_info
+{
+public:
+  /* Switch to the infrun state held on the fork_info identified by
+     PPTID.  If PPTID is the current inferior then no switch is done.  */
+  explicit scoped_switch_fork_info (ptid_t pptid)
+    : m_oldfp (nullptr)
+  {
+    if (pptid != inferior_ptid)
+      {
+	struct fork_info *newfp = nullptr;
+
+	/* Switch to pptid.  */
+	m_oldfp = find_fork_ptid (inferior_ptid);
+	gdb_assert (m_oldfp != nullptr);
+	newfp = find_fork_ptid (pptid);
+	gdb_assert (newfp != nullptr);
+	fork_save_infrun_state (m_oldfp, 1);
+	remove_breakpoints ();
+	fork_load_infrun_state (newfp);
+	insert_breakpoints ();
+      }
+  }
+
+  /* Restore the previously selected infrun state.  If the constructor
+     didn't need to switch states, then nothing is done here either.  */
+  ~scoped_switch_fork_info ()
+  {
+    if (m_oldfp != nullptr)
+      {
+	/* Switch back to inferior_ptid.  */
+	TRY
+	  {
+	    remove_breakpoints ();
+	    fork_load_infrun_state (m_oldfp);
+	    insert_breakpoints ();
+	  }
+	CATCH (ex, RETURN_MASK_ALL)
+	  {
+	    warning (_("Couldn't restore checkpoint state in %s: %s"),
+		     target_pid_to_str (m_oldfp->ptid), ex.message);
+	  }
+	END_CATCH
+      }
+  }
+
+  DISABLE_COPY_AND_ASSIGN (scoped_switch_fork_info);
+
+private:
+  /* The fork_info for the previously selected infrun state, or nullptr if
+     we were already in the desired state, and nothing needs to be
+     restored.  */
+  struct fork_info *m_oldfp;
+};
+
+static int
+inferior_call_waitpid (ptid_t pptid, int pid)
+{
+  struct objfile *waitpid_objf;
+  struct value *waitpid_fn = NULL;
+  int ret = -1;
+
+  scoped_switch_fork_info switch_fork_info (pptid);
+
+  /* Get the waitpid_fn.  */
+  if (lookup_minimal_symbol ("waitpid", NULL, NULL).minsym != NULL)
+    waitpid_fn = find_function_in_inferior ("waitpid", &waitpid_objf);
+  if (!waitpid_fn
+      && lookup_minimal_symbol ("_waitpid", NULL, NULL).minsym != NULL)
+    waitpid_fn = find_function_in_inferior ("_waitpid", &waitpid_objf);
+  if (waitpid_fn != nullptr)
+    {
+      struct gdbarch *gdbarch = get_current_arch ();
+      struct value *argv[3], *retv;
+
+      /* Get the argv.  */
+      argv[0] = value_from_longest (builtin_type (gdbarch)->builtin_int, pid);
+      argv[1] = value_from_pointer (builtin_type (gdbarch)->builtin_data_ptr, 0);
+      argv[2] = value_from_longest (builtin_type (gdbarch)->builtin_int, 0);
+
+      retv = call_function_by_hand (waitpid_fn, NULL, argv);
+
+      if (value_as_long (retv) >= 0)
+	ret = 0;
+    }
+
+  return ret;
+}
+
 /* Fork list <-> user interface.  */
 
 static void
-delete_fork_command (char *args, int from_tty)
+delete_checkpoint_command (const char *args, int from_tty)
 {
-  ptid_t ptid;
+  ptid_t ptid, pptid;
+  struct fork_info *fi;
 
   if (!args || !*args)
-    error (_("Requires argument (fork/checkpoint id to delete)"));
+    error (_("Requires argument (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 == minus_one_ptid)
+    error (_("No such checkpoint id, %s"), args);
+
+  if (ptid == inferior_ptid)
+    error (_("\
+Please switch to another checkpoint before deleting the current one"));
 
-  if (ptid_equal (ptid, inferior_ptid))
-    error (_("Please switch to another fork/checkpoint before deleting the current one"));
+  if (ptrace (PTRACE_KILL, ptid.pid (), 0, 0))
+    error (_("Unable to kill pid %s"), target_pid_to_str (ptid));
 
-  if (ptrace (PTRACE_KILL, PIDGET (ptid), 0, 0))
-    error (_("Unable to kill pid %s"), target_tid_to_str (ptid));
+  fi = find_fork_ptid (ptid);
+  gdb_assert (fi);
+  pptid = fi->parent_ptid;
 
   if (from_tty)
     printf_filtered (_("Killed %s\n"), target_pid_to_str (ptid));
 
   delete_fork (ptid);
+
+  /* If fi->parent_ptid is not a part of lwp but it's a part of checkpoint
+     list, waitpid the ptid.
+     If fi->parent_ptid is a part of lwp and it is stopped, waitpid the
+     ptid.  */
+  thread_info *parent = find_thread_ptid (pptid);
+  if ((parent == NULL && find_fork_ptid (pptid))
+      || (parent != NULL && parent->state == THREAD_STOPPED))
+    {
+      if (inferior_call_waitpid (pptid, ptid.pid ()))
+        warning (_("Unable to wait pid %s"), target_pid_to_str (ptid));
+    }
 }
 
 static void
-detach_fork_command (char *args, int from_tty)
+detach_checkpoint_command (const char *args, int from_tty)
 {
   ptid_t ptid;
 
   if (!args || !*args)
-    error (_("Requires argument (fork id to detach)"));
+    error (_("Requires argument (checkpoint 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 == minus_one_ptid)
+    error (_("No such checkpoint id, %s"), args);
 
-  if (ptid_equal (ptid, inferior_ptid))
-    error (_("Please switch to another fork before detaching the current one"));
+  if (ptid == inferior_ptid)
+    error (_("\
+Please switch to another checkpoint before detaching the current one"));
 
-  if (ptrace (PTRACE_DETACH, PIDGET (ptid), 0, 0))
+  if (ptrace (PTRACE_DETACH, ptid.pid (), 0, 0))
     error (_("Unable to detach %s"), target_pid_to_str (ptid));
 
   if (from_tty)
@@ -431,16 +599,14 @@ detach_fork_command (char *args, int from_tty)
   delete_fork (ptid);
 }
 
-/* Print information about currently known forks.  */
+/* Print information about currently known checkpoints.  */
 
 static void
-info_forks_command (char *arg, int from_tty)
+info_checkpoints_command (const char *arg, int from_tty)
 {
-  struct frame_info *cur_frame;
+  struct gdbarch *gdbarch = get_current_arch ();
   struct symtab_and_line sal;
-  struct symtab *cur_symtab;
   struct fork_info *fp;
-  int cur_line;
   ULONGEST pc;
   int requested = -1;
   struct fork_info *printed = NULL;
@@ -454,41 +620,31 @@ info_forks_command (char *arg, int from_tty)
 	continue;
 
       printed = fp;
-      if (ptid_equal (fp->ptid, inferior_ptid))
-	{
-	  printf_filtered ("* ");
-	  pc = read_pc ();
-	}
+      if (fp->ptid == inferior_ptid)
+	printf_filtered ("* ");
       else
-	{
-	  printf_filtered ("  ");
-	  pc = fp->pc;
-	}
+	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);
+      fputs_filtered (paddress (gdbarch, pc), 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);
-	}
+	printf_filtered (_(", file %s"),
+			 symtab_to_filename_for_display (sal.symtab));
       if (sal.line)
 	printf_filtered (_(", line %d"), sal.line);
       if (!sal.symtab && !sal.line)
 	{
-	  struct minimal_symbol *msym;
+	  struct bound_minimal_symbol msym;
 
 	  msym = lookup_minimal_symbol_by_pc (pc);
-	  if (msym)
-	    printf_filtered (", <%s>", SYMBOL_LINKAGE_NAME (msym));
+	  if (msym.minsym)
+	    printf_filtered (", <%s>", MSYMBOL_LINKAGE_NAME (msym.minsym));
 	}
 
       putchar_filtered ('\n');
@@ -496,144 +652,143 @@ info_forks_command (char *arg, int from_tty)
   if (printed == NULL)
     {
       if (requested > 0)
-	printf_filtered (_("No fork number %d.\n"), requested);
+	printf_filtered (_("No checkpoint number %d.\n"), requested);
       else
-	printf_filtered (_("No forks.\n"));
+	printf_filtered (_("No checkpoints.\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 PID of the process we're checkpointing.  */
+static int checkpointing_pid = 0;
 
-   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).  */
+int
+linux_fork_checkpointing_p (int pid)
+{
+  return (checkpointing_pid == pid);
+}
 
-static void 
-restore_detach_fork (void *arg)
+/* Callback for iterate over threads.  Used to check whether
+   the current inferior is multi-threaded.  Returns true as soon
+   as it sees the second thread of the current inferior.  */
+
+static int
+inf_has_multiple_thread_cb (struct thread_info *tp, void *data)
 {
-  detach_fork = *(int *) arg;
+  int *count_p = (int *) data;
+  
+  if (current_inferior ()->pid == tp->ptid.pid ())
+    (*count_p)++;
+  
+  /* Stop the iteration if multiple threads have been detected.  */
+  return *count_p > 1;
 }
 
-static struct cleanup *
-save_detach_fork (int *saved_val)
+/* Return true if the current inferior is multi-threaded.  */
+
+static int
+inf_has_multiple_threads (void)
 {
-  *saved_val = detach_fork;
-  return make_cleanup (restore_detach_fork, (void *) saved_val);
+  int count = 0;
+
+  iterate_over_threads (inf_has_multiple_thread_cb, &count);
+  return (count > 1);
 }
 
 static void
-checkpoint_command (char *args, int from_tty)
+checkpoint_command (const char *args, int from_tty)
 {
+  struct objfile *fork_objf;
+  struct gdbarch *gdbarch;
   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;
 
+  if (!target_has_execution) 
+    error (_("The program is not being run."));
+
+  /* Ensure that the inferior is not multithreaded.  */
+  update_thread_list ();
+  if (inf_has_multiple_threads ())
+    error (_("checkpoint: can't checkpoint multiple threads."));
+  
   /* 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 (lookup_minimal_symbol ("fork", NULL, NULL).minsym != NULL)
+    fork_fn = find_function_in_inferior ("fork", &fork_objf);
   if (!fork_fn)
-    if (lookup_minimal_symbol ("_fork", NULL, NULL) != NULL)
-      fork_fn = find_function_in_inferior ("fork");
+    if (lookup_minimal_symbol ("_fork", NULL, NULL).minsym != NULL)
+      fork_fn = find_function_in_inferior ("fork", &fork_objf);
   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);
+  gdbarch = get_objfile_arch (fork_objf);
+  ret = value_from_longest (builtin_type (gdbarch)->builtin_int, 0);
+
+  /* Tell linux-nat.c that we're checkpointing this inferior.  */
+  {
+    scoped_restore save_pid
+      = make_scoped_restore (&checkpointing_pid, inferior_ptid.pid ());
+
+    ret = call_function_by_hand (fork_fn, NULL, {});
+  }
+
   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);
+
+  fp = find_fork_pid (retpid);
+
   if (from_tty)
     {
       int parent_pid;
 
-      printf_filtered (_("checkpoint: fork returned pid %ld.\n"), 
-		       (long) retpid);
+      printf_filtered (_("checkpoint %d: fork returned pid %ld.\n"),
+		       fp != NULL ? fp->num : -1, (long) retpid);
       if (info_verbose)
 	{
-	  parent_pid = ptid_get_lwp (last_target_ptid);
+	  parent_pid = last_target_ptid.lwp ();
 	  if (parent_pid == 0)
-	    parent_pid = ptid_get_pid (last_target_ptid);
-	  printf_filtered (_("   gdb says parent = %ld.\n"), 
+	    parent_pid = last_target_ptid.pid ();
+	  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);
+  fp->parent_ptid = last_target_ptid;
 }
 
 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;
+  struct fork_info *oldfp;
 
-  if (!newfp)
-    error (_("No such fork/process"));
+  gdb_assert (newfp != NULL);
 
-  if (!oldfp)
-    oldfp = add_fork (ptid_get_pid (inferior_ptid));
+  oldfp = find_fork_ptid (inferior_ptid);
+  gdb_assert (oldfp != NULL);
 
   fork_save_infrun_state (oldfp, 1);
+  remove_breakpoints ();
   fork_load_infrun_state (newfp);
+  insert_breakpoints ();
 
-  printf_filtered (_("Switching to %s\n"), 
+  printf_filtered (_("Switching to %s\n"),
 		   target_pid_to_str (inferior_ptid));
 
-  print_stack_frame (get_selected_frame (NULL), 1, SRC_AND_LOC);
+  print_stack_frame (get_selected_frame (NULL), 1, SRC_AND_LOC, 1);
 }
 
-/* Switch inferior process (fork) context, by process id.  */
+/* Switch inferior process (checkpoint) context, by checkpoint 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)
+restart_command (const char *args, int from_tty)
 {
   struct fork_info *fp;
 
@@ -651,69 +806,36 @@ _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).  */
+  /* Restart command: restore the context of a specified checkpoint
+     process.  */
 
   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'."));
+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.  */
+     the fork list.  */
 
-  add_cmd ("checkpoint", class_obscure, delete_fork_command, _("\
-Delete a fork/checkpoint (experimental)."),
+  add_cmd ("checkpoint", class_obscure, delete_checkpoint_command, _("\
+Delete a checkpoint (experimental)."),
 	   &deletelist);
 
-  /* Detach checkpoint command: release the process to run independently, 
+  /* Detach checkpoint command: release the process to run independently,
      and remove it from the fork list.  */
 
-  add_cmd ("checkpoint", class_obscure, detach_fork_command, _("\
-Detach from a fork/checkpoint (experimental)."),
+  add_cmd ("checkpoint", class_obscure, detach_checkpoint_command, _("\
+Detach from a checkpoint (experimental)."),
 	   &detachlist);
 
-  /* Info checkpoints command: list all forks/checkpoints 
+  /* 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_alias_cmd ("fork", "checkpoint", class_obscure, 1, &deletelist);
-  add_alias_cmd ("fork", "checkpoint", class_obscure, 1, &detachlist);
-  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'."));
+  add_info ("checkpoints", info_checkpoints_command,
+	    _("IDs of currently known checkpoints."));
 }