/* GNU/Linux native-dependent code for debugging multiple forks.
- Copyright (C) 2005, 2006, 2007, 2008, 2009 Free Software Foundation, Inc.
+ Copyright (C) 2005-2018 Free Software Foundation, Inc.
This file is part of GDB.
#include "defs.h"
#include "arch-utils.h"
#include "inferior.h"
+#include "infrun.h"
#include "regcache.h"
#include "gdbcmd.h"
#include "infcall.h"
#include "objfiles.h"
-#include "gdb_assert.h"
-#include "gdb_string.h"
#include "linux-fork.h"
#include "linux-nat.h"
+#include "gdbthread.h"
+#include "source.h"
-#include <sys/ptrace.h>
+#include "nat/gdb_ptrace.h"
#include "gdb_wait.h"
-#include <sys/param.h>
-#include "gdb_dirent.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. */
off_t *filepos; /* Set of open file descriptors' offsets. */
int maxfd;
return (fork_list != NULL);
}
+/* Return the last fork in the list. */
+
+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 *
{
struct fork_info *fp;
- if (fork_list == NULL && pid != PIDGET (inferior_ptid))
+ if (fork_list == NULL && pid != ptid_get_pid (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 */
+ add_fork (ptid_get_pid (inferior_ptid)); /* 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;
}
if (fp)
{
if (fp->savedregs)
- regcache_xfree (fp->savedregs);
+ delete fp->savedregs;
if (fp->filepos)
xfree (fp->filepos);
xfree (fp);
fpprev = NULL;
+ linux_target->low_forget_process (ptid_get_pid (ptid));
+
for (fp = fork_list; fp; fpprev = fp, fp = fp->next)
if (ptid_equal (fp->ptid, ptid))
break;
{
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]);
}
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 = regcache_read_pc (get_current_regcache ());
+ 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. */
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;
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) ptid_get_pid (fp->ptid));
if ((d = opendir (path)) != NULL)
{
long tmp;
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++)
for (fp = fork_list; fp; fp = fp->next)
{
- pid = PIDGET (fp->ptid);
+ pid = ptid_get_pid (fp->ptid);
do {
/* Use SIGKILL instead of PTRACE_KILL because the former works even
if the thread is running, while the later doesn't. */
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);
/* OK, presumably inferior_ptid is the one who has exited.
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));
the first available. */
void
-linux_fork_detach (char *args, int from_tty)
+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, PIDGET (inferior_ptid), 0, 0))
+ if (ptrace (PTRACE_DETACH, ptid_get_pid (inferior_ptid), 0, 0))
error (_("Unable to detach %s"), target_pid_to_str (inferior_ptid));
delete_fork (inferior_ptid);
delete_fork (inferior_ptid);
}
+static void
+inferior_call_waitpid_cleanup (void *fp)
+{
+ struct fork_info *oldfp = (struct fork_info *) fp;
+
+ if (oldfp)
+ {
+ /* Switch back to inferior_ptid. */
+ remove_breakpoints ();
+ fork_load_infrun_state (oldfp);
+ insert_breakpoints ();
+ }
+}
+
+static int
+inferior_call_waitpid (ptid_t pptid, int pid)
+{
+ struct objfile *waitpid_objf;
+ struct value *waitpid_fn = NULL;
+ struct value *argv[4], *retv;
+ struct gdbarch *gdbarch = get_current_arch ();
+ struct fork_info *oldfp = NULL, *newfp = NULL;
+ struct cleanup *old_cleanup;
+ int ret = -1;
+
+ if (!ptid_equal (pptid, inferior_ptid))
+ {
+ /* Switch to pptid. */
+ oldfp = find_fork_ptid (inferior_ptid);
+ gdb_assert (oldfp != NULL);
+ newfp = find_fork_ptid (pptid);
+ gdb_assert (newfp != NULL);
+ fork_save_infrun_state (oldfp, 1);
+ remove_breakpoints ();
+ fork_load_infrun_state (newfp);
+ insert_breakpoints ();
+ }
+
+ old_cleanup = make_cleanup (inferior_call_waitpid_cleanup, oldfp);
+
+ /* 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)
+ goto out;
+
+ /* 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);
+ argv[3] = 0;
+
+ retv = call_function_by_hand (waitpid_fn, NULL, 3, argv);
+ if (value_as_long (retv) < 0)
+ goto out;
+
+ ret = 0;
+
+out:
+ do_cleanups (old_cleanup);
+ return ret;
+}
+
/* Fork list <-> user interface. */
static void
-delete_checkpoint_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 (checkpoint id to delete)"));
error (_("\
Please switch to another checkpoint before deleting the current one"));
- if (ptrace (PTRACE_KILL, PIDGET (ptid), 0, 0))
+ if (ptrace (PTRACE_KILL, ptid_get_pid (ptid), 0, 0))
error (_("Unable to kill pid %s"), target_pid_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_get_pid (ptid)))
+ warning (_("Unable to wait pid %s"), target_pid_to_str (ptid));
+ }
}
static void
-detach_checkpoint_command (char *args, int from_tty)
+detach_checkpoint_command (const char *args, int from_tty)
{
ptid_t 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_get_pid (ptid), 0, 0))
error (_("Unable to detach %s"), target_pid_to_str (ptid));
if (from_tty)
/* Print information about currently known checkpoints. */
static void
-info_checkpoints_command (char *arg, int from_tty)
+info_checkpoints_command (const char *arg, int from_tty)
{
struct gdbarch *gdbarch = get_current_arch ();
- struct frame_info *cur_frame;
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;
printed = fp;
if (ptid_equal (fp->ptid, inferior_ptid))
- {
- printf_filtered ("* ");
- pc = regcache_read_pc (get_current_regcache ());
- }
+ printf_filtered ("* ");
else
- {
- printf_filtered (" ");
- pc = regcache_read_pc (fp->savedregs);
- }
+ 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)"));
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');
return (checkpointing_pid == pid);
}
+/* 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)
+{
+ int *count_p = (int *) data;
+
+ if (current_inferior ()->pid == ptid_get_pid (tp->ptid))
+ (*count_p)++;
+
+ /* Stop the iteration if multiple threads have been detected. */
+ return *count_p > 1;
+}
+
+/* Return true if the current inferior is multi-threaded. */
+
+static int
+inf_has_multiple_threads (void)
+{
+ 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 value *fork_fn = NULL, *ret;
struct fork_info *fp;
pid_t retpid;
- struct cleanup *old_chain;
- long i;
+ 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)
+ 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)
+ 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 (gdbarch)->builtin_int, 0);
/* Tell linux-nat.c that we're checkpointing this inferior. */
- old_chain = make_cleanup_restore_integer (&checkpointing_pid);
- checkpointing_pid = PIDGET (inferior_ptid);
+ {
+ scoped_restore save_pid
+ = make_scoped_restore (&checkpointing_pid, ptid_get_pid (inferior_ptid));
+
+ ret = call_function_by_hand (fork_fn, NULL, 0, &ret);
+ }
- 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);
+
+ 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);
}
}
- 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
{
/* Now we attempt to switch processes. */
struct fork_info *oldfp;
- ptid_t ptid;
- int id, i;
gdb_assert (newfp != NULL);
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 (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;
{
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);
-
/* Checkpoint command: create a fork of the inferior process
and set it aside for later debugging. */
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
the fork list. */
projects / deliverable / binutils-gdb.git / blobdiff