/* GNU/Linux native-dependent code for debugging multiple forks.
- Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010
- Free Software Foundation, Inc.
+ Copyright (C) 2005-2013 Free Software Foundation, Inc.
This file is part of GDB.
#include "gdb_string.h"
#include "linux-fork.h"
#include "linux-nat.h"
+#include "gdbthread.h"
+#include "source.h"
#include <sys/ptrace.h>
#include "gdb_wait.h"
{
struct fork_info *next;
ptid_t ptid;
- int num; /* Convenient handle (GDB fork id) */
+ ptid_t parent_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. */
fpprev = NULL;
+ linux_nat_forget_process (ptid_get_pid (ptid));
+
for (fp = fork_list; fp; fpprev = fp, fp = fp->next)
if (ptid_equal (fp->ptid, ptid))
break;
delete_fork (inferior_ptid);
}
+static void
+inferior_call_waitpid_cleanup (void *fp)
+{
+ struct fork_info *oldfp = 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) != NULL)
+ waitpid_fn = find_function_in_inferior ("waitpid", &waitpid_objf);
+ if (!waitpid_fn && lookup_minimal_symbol ("_waitpid", NULL, NULL) != 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, 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)
{
- ptid_t ptid;
+ ptid_t ptid, pptid;
+ struct fork_info *fi;
if (!args || !*args)
error (_("Requires argument (checkpoint id to delete)"));
if (ptrace (PTRACE_KILL, PIDGET (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 stoped, waitpid the
+ ptid. */
+ if ((!find_thread_ptid (pptid) && find_fork_ptid (pptid))
+ || (find_thread_ptid (pptid) && is_stopped (pptid)))
+ {
+ if (inferior_call_waitpid (pptid, PIDGET (ptid)))
+ warning (_("Unable to wait pid %s"), target_pid_to_str (ptid));
+ }
}
static void
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>", SYMBOL_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)
{
pid_t retpid;
struct cleanup *old_chain;
+ 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 (!fp)
error (_("Failed to find new fork"));
fork_save_infrun_state (fp, 1);
+ fp->parent_ptid = last_target_ptid;
}
static void