/* GNU/Linux native-dependent code for debugging multiple forks.
- Copyright (C) 2005 Free Software Foundation, Inc.
+ Copyright (C) 2005, 2006, 2007, 2008 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,
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 <http://www.gnu.org/licenses/>. */
#include "defs.h"
#include "inferior.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 <sys/ptrace.h>
-#include <sys/wait.h>
+#include "gdb_wait.h"
#include <sys/param.h>
-#include <dirent.h>
+#include "gdb_dirent.h"
#include <ctype.h>
struct fork_info *fork_list;
{
struct fork_info *fp;
- if (fork_list == NULL &&
- pid != PIDGET (inferior_ptid))
+ 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
}
fp = XZALLOC (struct fork_info);
- fp->ptid = pid_to_ptid (pid);
+ fp->ptid = ptid_build (pid, pid, 0);
fp->num = ++highest_fork_num;
fp->next = fork_list;
fork_list = fp;
for (fp = fork_list; fp; fp = fpnext)
{
fpnext = fp->next;
+ delete_inferior (ptid_get_pid (fp->ptid));
free_fork (fp);
}
extern void nullify_last_target_wait_ptid ();
int i;
+ inferior_ptid = fp->ptid;
+
+ linux_nat_switch_fork (inferior_ptid);
+
if (fp->savedregs && fp->clobber_regs)
- regcache_cpy (current_regcache, fp->savedregs);
+ regcache_cpy (get_current_regcache (), fp->savedregs);
+ registers_changed ();
+ reinit_frame_cache ();
+
+ stop_pc = read_pc ();
nullify_last_target_wait_ptid ();
/* Now restore the file positions of open file descriptors. */
if (fp->savedregs)
regcache_xfree (fp->savedregs);
- fp->savedregs = regcache_dup (current_regcache);
+ fp->savedregs = regcache_dup (get_current_regcache ());
fp->clobber_regs = clobber_regs;
fp->pc = read_pc ();
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;
- 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);
+ for (fp = fork_list; fp; fp = fp->next)
+ {
+ pid = PIDGET (fp->ptid);
+ do {
+ /* 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. */
}
/* The current inferior_ptid has exited, but there are other viable
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));
- }
+ /* Delete process from GDB's inferior list. */
+ delete_inferior (ptid_get_pid (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);
+ 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);
}
/* Fork list <-> user interface. */
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))
+ if (ptrace (PTRACE_KILL, PIDGET (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);
+ /* Delete process from GDB's inferior list. */
+ delete_inferior (ptid_get_pid (ptid));
}
static void
if (ptid_equal (ptid, inferior_ptid))
error (_("Please switch to another fork before detaching the current one"));
- if (ptrace (PTRACE_DETACH, ptid, 0, 0))
+ if (ptrace (PTRACE_DETACH, PIDGET (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);
+ /* Delete process from GDB's process table. */
+ detach_inferior (ptid_get_pid (ptid));
}
/* Print information about currently known forks. */
struct fork_info *fp;
int cur_line;
ULONGEST pc;
+ int requested = -1;
+ struct fork_info *printed = NULL;
+
+ if (arg && *arg)
+ requested = (int) parse_and_eval_long (arg);
for (fp = fork_list; fp; fp = fp->next)
{
+ if (requested > 0 && fp->num != requested)
+ continue;
+
+ printed = fp;
if (ptid_equal (fp->ptid, inferior_ptid))
{
printf_filtered ("* ");
if (fp->num == 0)
printf_filtered (_(" (main process)"));
printf_filtered (_(" at "));
- deprecated_print_address_numeric (pc, 1, gdb_stdout);
+ fputs_filtered (paddress (pc), gdb_stdout);
sal = find_pc_line (pc, 0);
if (sal.symtab)
putchar_filtered ('\n');
}
+ if (printed == NULL)
+ {
+ if (requested > 0)
+ printf_filtered (_("No fork number %d.\n"), requested);
+ else
+ printf_filtered (_("No forks.\n"));
+ }
}
/* Save/restore mode variable 'detach_fork':
static void
checkpoint_command (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;
/* Make this temp var static, 'cause it's used in the error context. */
static int temp_detach_fork;
+ /* Remove breakpoints, so that they are not inserted
+ in the forked process. */
+ remove_breakpoints ();
+
/* 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");
+ 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");
+ 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);
+ gdbarch = get_objfile_arch (fork_objf);
+ ret = value_from_longest (builtin_type (gdbarch)->builtin_int, 0);
old_chain = save_detach_fork (&temp_detach_fork);
detach_fork = 0;
ret = call_function_by_hand (fork_fn, 0, &ret);
if (!fp)
error (_("Failed to find new fork"));
fork_save_infrun_state (fp, 1);
+ insert_breakpoints ();
}
static void
error (_("No such fork/process"));
if (!oldfp)
- {
- oldfp = add_fork (ptid_get_pid (inferior_ptid));
- }
+ oldfp = add_fork (ptid_get_pid (inferior_ptid));
fork_save_infrun_state (oldfp, 1);
- inferior_ptid = newfp->ptid;
+ remove_breakpoints ();
fork_load_infrun_state (newfp);
- registers_changed ();
- reinit_frame_cache ();
- stop_pc = read_pc ();
- select_frame (get_current_frame ());
+ insert_breakpoints ();
printf_filtered (_("Switching to %s\n"),
target_pid_to_str (inferior_ptid));
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
+ /* 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)."));
+ add_cmd ("checkpoint", class_obscure, delete_fork_command, _("\
+Delete a fork/checkpoint (experimental)."),
+ &deletelist);
- /* Detach-checkpoint command: release the process to run independantly,
+ /* Detach checkpoint command: release the process to run independently,
and remove it from the fork list. */
- add_com ("detach-checkpoint", class_obscure, detach_fork_command, _("\
-Detach from a fork/checkpoint (experimental)."));
+ add_cmd ("checkpoint", class_obscure, detach_fork_command, _("\
+Detach from a fork/checkpoint (experimental)."),
+ &detachlist);
/* Info checkpoints command: list all forks/checkpoints
currently under gdb's control. */
/* 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_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>"). */