X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=gdb%2Flinux-fork.c;h=d323a716e3992d33e520873674de79f651ccb678;hb=7d8062de98203eeec70d4439ab460b9ef50a2e0f;hp=9f0c0d11277eced146b911e91a5c5b61fbdd6b99;hpb=594f77850bb22a2cec4e8fc44c7ea735a6270eb2;p=deliverable%2Fbinutils-gdb.git
diff --git a/gdb/linux-fork.c b/gdb/linux-fork.c
index 9f0c0d1127..d323a716e3 100644
--- a/gdb/linux-fork.c
+++ b/gdb/linux-fork.c
@@ -1,12 +1,12 @@
/* 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.
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
+ the Free Software Foundation; either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
@@ -15,151 +15,150 @@
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. */
+ along with this program. If not, see . */
#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 "gdbthread.h"
+#include "source.h"
-#include
-#include
-#include
+#include "nat/gdb_ptrace.h"
+#include "common/gdb_wait.h"
#include
#include
-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). */
+#include
/* 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;
+ explicit fork_info (pid_t pid)
+ : ptid (pid, pid, 0)
+ {
+ }
+
+ ~fork_info ()
+ {
+ /* 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 (savedregs)
+ delete savedregs;
+ if (filepos)
+ xfree (filepos);
+ }
+
+ ptid_t ptid = null_ptid;
+ ptid_t parent_ptid = null_ptid;
+
+ /* Convenient handle (GDB fork id). */
+ int num = 0;
+
+ /* Convenient for info fork, saves having to actually switch
+ contexts. */
+ readonly_detached_regcache *savedregs = nullptr;
+
+ CORE_ADDR pc = 0;
+
+ /* Set of open file descriptors' offsets. */
+ off_t *filepos = nullptr;
+
+ int maxfd = 0;
};
+static std::list fork_list;
+static int highest_fork_num;
+
/* Fork list methods: */
-extern int
+int
forks_exist_p (void)
{
- return (fork_list != NULL);
+ return !fork_list.empty ();
}
-/* Add a fork to internal fork list.
- Called from linux child_follow_fork. */
+/* Return the last fork in the list. */
-extern struct fork_info *
-add_fork (pid_t pid)
+static struct fork_info *
+find_last_fork (void)
{
- struct fork_info *fp;
+ if (fork_list.empty ())
+ return NULL;
- 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 = ptid_build (pid, pid, 0);
- fp->num = ++highest_fork_num;
- fp->next = fork_list;
- fork_list = fp;
- return fp;
+ return &fork_list.back ();
}
-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);
- }
-}
+/* Return true iff there's one fork in the list. */
-static void
-delete_fork (ptid_t ptid)
+static bool
+one_fork_p ()
{
- struct fork_info *fp, *fpprev;
-
- fpprev = NULL;
+ return (!fork_list.empty ()
+ && &fork_list.front () == &fork_list.back ());
+}
- for (fp = fork_list; fp; fpprev = fp, fp = fp->next)
- if (ptid_equal (fp->ptid, ptid))
- break;
+/* Add a new fork to the internal fork list. */
- if (!fp)
- return;
+void
+add_fork (pid_t pid)
+{
+ fork_list.emplace_back (pid);
- if (fpprev)
- fpprev->next = fp->next;
- else
- fork_list = fp->next;
+ if (one_fork_p ())
+ highest_fork_num = 0;
- free_fork (fp);
+ fork_info *fp = &fork_list.back ();
+ fp->num = ++highest_fork_num;
+}
- /* 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);
- }
+static void
+delete_fork (ptid_t ptid)
+{
+ linux_target->low_forget_process (ptid.pid ());
+
+ for (auto it = fork_list.begin (); it != fork_list.end (); ++it)
+ if (it->ptid == ptid)
+ {
+ fork_list.erase (it);
+
+ /* 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 (one_fork_p () && fork_list.front ().ptid == inferior_ptid)
+ {
+ /* Last fork -- delete from list and handle as solo
+ process (should be a safe recursion). */
+ delete_fork (inferior_ptid);
+ }
+ return;
+ }
}
/* 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;
+ for (fork_info &fi : fork_list)
+ if (fi.ptid == ptid)
+ return &fi;
return NULL;
}
@@ -168,11 +167,9 @@ find_fork_ptid (ptid_t ptid)
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;
+ for (fork_info &fi : fork_list)
+ if (fi.num == num)
+ return &fi;
return NULL;
}
@@ -181,11 +178,9 @@ find_fork_id (int num)
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;
+ for (fork_info &fi : fork_list)
+ if (pid == fi.ptid.pid ())
+ return &fi;
return NULL;
}
@@ -197,29 +192,12 @@ fork_id_to_ptid (int 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;
+ return ptid_t (-1);
}
/* 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
@@ -227,7 +205,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]);
}
@@ -240,17 +218,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);
+ if (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. */
@@ -265,65 +242,59 @@ fork_load_infrun_state (struct fork_info *fp)
}
}
-/* Save infrun state for the fork PTID.
- Exported for use by linux child_follow_fork. */
+/* Save infrun state for the fork FP. */
-extern void
-fork_save_infrun_state (struct fork_info *fp, int clobber_regs)
+static void
+fork_save_infrun_state (struct fork_info *fp)
{
- 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->clobber_regs = clobber_regs;
- fp->pc = read_pc ();
+ fp->savedregs = new readonly_detached_regcache (*get_current_regcache ());
+ fp->pc = regcache_read_pc (get_current_regcache ());
- 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, PATH_MAX, "/proc/%ld/fd", (long) fp->ptid.pid ());
+ if ((d = opendir (path)) != NULL)
{
- /* 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)
{
- 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);
+ /* 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 = XRESIZEVEC (off_t, fp->filepos, fp->maxfd + 1);
+
+ /* 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
+void
linux_fork_killall (void)
{
/* Walk list and kill every pid. No need to treat the
@@ -331,38 +302,42 @@ linux_fork_killall (void)
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. */
- struct fork_info *fp;
- pid_t pid, ret;
- int status;
- for (fp = fork_list; fp; fp = fp->next)
+ for (fork_info &fi : fork_list)
{
- pid = PIDGET (fp->ptid);
+ pid_t pid = fi.ptid.pid ();
+ int status;
+ pid_t ret;
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
died. MVS comment cut-and-pasted from linux-nat. */
} while (ret == pid && WIFSTOPPED (status));
}
- init_fork_list (); /* Clear list, prepare to start fresh. */
+
+ /* Clear list, prepare to start fresh. */
+ fork_list.clear ();
}
/* 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
+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,125 +347,257 @@ linux_fork_mourn_inferior (void)
/* 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);
+ gdb_assert (!fork_list.empty ());
- 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));
+ target_pid_to_str (inferior_ptid).c_str ());
/* If there's only one fork, switch back to non-fork mode. */
- if (fork_list->next == NULL)
+ if (one_fork_p ())
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).c_str ());
+
+ 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.empty ());
+
+ fork_load_infrun_state (&fork_list.front ());
+
+ if (from_tty)
+ printf_filtered (_("[Switching to %s]\n"),
+ target_pid_to_str (inferior_ptid).c_str ());
+
+ /* If there's only one fork, switch back to non-fork mode. */
+ if (one_fork_p ())
+ 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);
+ 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 (const gdb_exception &ex)
+ {
+ warning (_("Couldn't restore checkpoint state in %s: %s"),
+ target_pid_to_str (m_oldfp->ptid).c_str (),
+ ex.what ());
+ }
+ }
+ }
+
+ 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).c_str ());
- 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));
+ printf_filtered (_("Killed %s\n"), target_pid_to_str (ptid).c_str ());
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).c_str ());
+ }
}
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))
- error (_("Unable to detach %s"), target_pid_to_str (ptid));
+ if (ptrace (PTRACE_DETACH, ptid.pid (), 0, 0))
+ error (_("Unable to detach %s"), target_pid_to_str (ptid).c_str ());
if (from_tty)
- printf_filtered (_("Detached %s\n"), target_pid_to_str (ptid));
+ printf_filtered (_("Detached %s\n"), target_pid_to_str (ptid).c_str ());
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 symtab_and_line sal;
- struct symtab *cur_symtab;
- struct fork_info *fp;
- int cur_line;
- ULONGEST pc;
+ struct gdbarch *gdbarch = get_current_arch ();
int requested = -1;
- struct fork_info *printed = NULL;
+ const fork_info *printed = NULL;
if (arg && *arg)
requested = (int) parse_and_eval_long (arg);
- for (fp = fork_list; fp; fp = fp->next)
+ for (const fork_info &fi : fork_list)
{
- if (requested > 0 && fp->num != requested)
+ if (requested > 0 && fi.num != requested)
continue;
- printed = fp;
- if (ptid_equal (fp->ptid, inferior_ptid))
- {
- printf_filtered ("* ");
- pc = read_pc ();
- }
+ printed = &fi;
+ if (fi.ptid == inferior_ptid)
+ printf_filtered ("* ");
else
- {
- printf_filtered (" ");
- pc = fp->pc;
- }
- printf_filtered ("%d %s", fp->num, target_pid_to_str (fp->ptid));
- if (fp->num == 0)
+ printf_filtered (" ");
+
+ ULONGEST pc = fi.pc;
+ printf_filtered ("%d %s", fi.num, target_pid_to_str (fi.ptid).c_str ());
+ if (fi.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);
+ symtab_and_line 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');
@@ -498,144 +605,141 @@ 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). */
-
-static void
-restore_detach_fork (void *arg)
+int
+linux_fork_checkpointing_p (int pid)
{
- detach_fork = *(int *) arg;
+ return (checkpointing_pid == pid);
}
-static struct cleanup *
-save_detach_fork (int *saved_val)
+/* Return true if the current inferior is multi-threaded. */
+
+static bool
+inf_has_multiple_threads ()
{
- *saved_val = detach_fork;
- return make_cleanup (restore_detach_fork, (void *) saved_val);
+ int count = 0;
+
+ /* Return true as soon as we see the second thread of the current
+ inferior. */
+ for (thread_info *tp ATTRIBUTE_UNUSED : current_inferior ()->threads ())
+ if (++count > 1)
+ return true;
+
+ return false;
}
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);
+
+ if (one_fork_p ())
+ {
+ /* Special case -- if this is the first fork in the list (the
+ list was hitherto empty), then add inferior_ptid first, as a
+ special zeroeth fork id. */
+ fork_list.emplace_front (inferior_ptid.pid ());
+ }
+
+ fork_save_infrun_state (fp);
+ 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);
+ fork_save_infrun_state (oldfp);
+ remove_breakpoints ();
fork_load_infrun_state (newfp);
+ insert_breakpoints ();
- 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)"));
+ printf_filtered (_("Switching to %s\n"),
+ target_pid_to_str (inferior_ptid).c_str ());
- if ((fp = find_fork_id (parse_and_eval_long (args))) == NULL)
- error (_("Not found: fork id %s"), args);
-
- linux_fork_context (fp, from_tty);
+ print_stack_frame (get_selected_frame (NULL), 1, SRC_AND_LOC, 1);
}
-/* Switch inferior process (fork) context, by checkpoint id. */
+/* Switch inferior process (checkpoint) 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,71 +755,36 @@ restart_command (char *args, int 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). */
+ /* Restart command: restore the context of a specified checkpoint
+ process. */
add_com ("restart", class_obscure, restart_command, _("\
-restart : 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 " (by analogy to "thread "). */
- add_com ("fork", class_obscure, fork_command, _("\
-fork : Switch between forked processes.\n\
-Argument 'n' is fork ID, as displayed by 'info forks'."));
-
- /* "process " as opposed to "fork ". */
- add_com ("process", class_obscure, process_command, _("\
-process : 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."));
}