--- /dev/null
+/* 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'."));
+}
#endif
#include <sys/ptrace.h>
#include "linux-nat.h"
+#include "linux-fork.h"
#include "gdbthread.h"
#include "gdbcmd.h"
#include "regcache.h"
the use of the multi-threaded target. */
static struct target_ops *linux_ops;
-/* The saved to_xfer_partial method, inherited from inf-ptrace.c. Called
- by our to_xfer_partial. */
-static LONGEST (*super_xfer_partial) (struct target_ops *, enum target_object,
- const char *, gdb_byte *, const gdb_byte *,
+/* The saved to_xfer_partial method, inherited from inf-ptrace.c.
+ Called by our to_xfer_partial. */
+static LONGEST (*super_xfer_partial) (struct target_ops *,
+ enum target_object,
+ const char *, gdb_byte *,
+ const gdb_byte *,
ULONGEST, LONGEST);
+/* The saved to_mourn_inferior method, inherited from inf-ptrace.c.
+ Called by our to_mourn_inferior. */
+static void (*super_mourn_inferior) (void);
+
static int debug_linux_nat;
static void
show_debug_linux_nat (struct ui_file *file, int from_tty,
also, but they'll be reinserted below. */
detach_breakpoints (child_pid);
- if (debug_linux_nat)
+ /* Detach new forked process? */
+ if (detach_fork)
{
- target_terminal_ours ();
- fprintf_unfiltered (gdb_stdlog,
- "Detaching after fork from child process %d.\n",
- child_pid);
- }
+ if (debug_linux_nat)
+ {
+ target_terminal_ours ();
+ fprintf_filtered (gdb_stdlog,
+ "Detaching after fork from child process %d.\n",
+ child_pid);
+ }
- ptrace (PTRACE_DETACH, child_pid, 0, 0);
+ ptrace (PTRACE_DETACH, child_pid, 0, 0);
+ }
+ else
+ {
+ struct fork_info *fp;
+ /* Retain child fork in ptrace (stopped) state. */
+ fp = find_fork_pid (child_pid);
+ if (!fp)
+ fp = add_fork (child_pid);
+ fork_save_infrun_state (fp, 0);
+ }
if (has_vforked)
{
if (debug_linux_nat)
{
target_terminal_ours ();
- fprintf_unfiltered (gdb_stdlog,
- "Attaching after fork to child process %d.\n",
- child_pid);
+ fprintf_filtered (gdb_stdlog,
+ "Attaching after fork to child process %d.\n",
+ child_pid);
}
/* If we're vforking, we may want to hold on to the parent until
if (has_vforked)
linux_parent_pid = parent_pid;
+ else if (!detach_fork)
+ {
+ struct fork_info *fp;
+ /* Retain parent fork in ptrace (stopped) state. */
+ fp = find_fork_pid (parent_pid);
+ if (!fp)
+ fp = add_fork (parent_pid);
+ fork_save_infrun_state (fp, 0);
+ }
else
- target_detach (NULL, 0);
+ {
+ target_detach (NULL, 0);
+ }
inferior_ptid = pid_to_ptid (child_pid);
/* Reinstall ourselves, since we might have been removed in
target_detach (which does other necessary cleanup). */
+
push_target (ops);
/* Reset breakpoints in the child as appropriate. */
if (pid == 0)
return;
- /* If we're stopped while forking and we haven't followed yet, kill the
- other task. We need to do this first because the parent will be
- sleeping if this is a vfork. */
-
- get_last_target_status (&last_ptid, &last);
-
- if (last.kind == TARGET_WAITKIND_FORKED
- || last.kind == TARGET_WAITKIND_VFORKED)
+ /* First cut -- let's crudely do everything inline. */
+ if (forks_exist_p ())
{
- ptrace (PT_KILL, last.value.related_pid, 0, 0);
- wait (&status);
+ linux_fork_killall ();
+ pop_target ();
+ generic_mourn_inferior ();
}
+ else
+ {
+ /* If we're stopped while forking and we haven't followed yet,
+ kill the other task. We need to do this first because the
+ parent will be sleeping if this is a vfork. */
- /* Kill the current process. */
- ptrace (PT_KILL, pid, 0, 0);
- ret = wait (&status);
+ get_last_target_status (&last_ptid, &last);
- /* We might get a SIGCHLD instead of an exit status. This is
- aggravated by the first kill above - a child has just died. */
+ if (last.kind == TARGET_WAITKIND_FORKED
+ || last.kind == TARGET_WAITKIND_VFORKED)
+ {
+ ptrace (PT_KILL, last.value.related_pid, 0, 0);
+ wait (&status);
+ }
- while (ret == pid && WIFSTOPPED (status))
- {
+ /* Kill the current process. */
ptrace (PT_KILL, pid, 0, 0);
ret = wait (&status);
- }
- target_mourn_inferior ();
+ /* We might get a SIGCHLD instead of an exit status. This is
+ aggravated by the first kill above - a child has just died. */
+
+ while (ret == pid && WIFSTOPPED (status))
+ {
+ ptrace (PT_KILL, pid, 0, 0);
+ ret = wait (&status);
+ }
+ target_mourn_inferior ();
+ }
}
/* On GNU/Linux there are no real LWP's. The closest thing to LWP's
int random_selector;
struct lwp_info *event_lp;
- /* Record the wait status for the origional LWP. */
+ /* Record the wait status for the original LWP. */
(*orig_lp)->status = *status;
/* Give preference to any LWP that is being single-stepped. */
return lp->resumed;
}
+/* Local mourn_inferior -- we need to override mourn_inferior
+ so that we can do something clever if one of several forks
+ has exited. */
+
+static void
+child_mourn_inferior (void)
+{
+ int status;
+
+ if (! forks_exist_p ())
+ {
+ /* Normal case, no other forks available. */
+ super_mourn_inferior ();
+ return;
+ }
+ else
+ {
+ /* Multi-fork case. The current inferior_ptid has exited, but
+ there are other viable forks to debug. Delete the exiting
+ one and context-switch to the first available. */
+ linux_fork_mourn_inferior ();
+ }
+}
+
/* We need to override child_wait to support attaching to cloned
processes, since a normal wait (as done by the default version)
ignores those processes. */
super_xfer_partial = t->to_xfer_partial;
t->to_xfer_partial = linux_xfer_partial;
+ super_mourn_inferior = t->to_mourn_inferior;
+ t->to_mourn_inferior = child_mourn_inferior;
+
linux_ops = t;
return t;
}
/* ... except during a sigsuspend. */
sigdelset (&suspend_mask, cancel);
}
+
projects / external / binutils.git / commitdiff