X-Git-Url: http://drtracing.org/?a=blobdiff_plain;f=gdb%2Flinux-fork.c;h=27603b36c94a880822d8a26cbbbd1c2c14fc911c;hb=a88d0bb33c28bc51c0f53cdd5c42d00217a1d771;hp=b89e8b52981fc986eec8e42cbc01f6797eafb260;hpb=5af949e350b923403600c1da34774b49a77c925c;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/linux-fork.c b/gdb/linux-fork.c index b89e8b5298..27603b36c9 100644 --- a/gdb/linux-fork.c +++ b/gdb/linux-fork.c @@ -1,6 +1,6 @@ /* GNU/Linux native-dependent code for debugging multiple forks. - Copyright (C) 2005, 2006, 2007, 2008, 2009 Free Software Foundation, Inc. + Copyright (C) 2005-2015 Free Software Foundation, Inc. This file is part of GDB. @@ -20,19 +20,19 @@ #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 #include "gdb_wait.h" -#include -#include "gdb_dirent.h" +#include #include struct fork_info *fork_list; @@ -41,50 +41,46 @@ 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). */ + 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 +int forks_exist_p (void) { return (fork_list != NULL); } -/* Add a fork to internal fork list. - Called from linux child_follow_fork. */ +/* Add a fork to the internal fork list. */ -extern struct fork_info * +struct fork_info * add_fork (pid_t pid) { 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 = XCNEW (struct fork_info); fp->ptid = ptid_build (pid, pid, 0); fp->num = ++highest_fork_num; fp->next = fork_list; @@ -124,6 +120,8 @@ delete_fork (ptid_t ptid) 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; @@ -138,7 +136,7 @@ delete_fork (ptid_t ptid) free_fork (fp); - /* Special case: if there is now only one process in the list, + /* 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. */ @@ -211,7 +209,6 @@ init_fork_list (void) for (fp = fork_list; fp; fp = fpnext) { fpnext = fp->next; - delete_inferior (ptid_get_pid (fp->ptid)); free_fork (fp); } @@ -220,7 +217,7 @@ init_fork_list (void) /* 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 @@ -241,9 +238,7 @@ 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); @@ -269,10 +264,10 @@ fork_load_infrun_state (struct fork_info *fp) /* Save infrun state for the fork PTID. Exported for use by linux child_follow_fork. */ -extern void +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; @@ -281,13 +276,13 @@ fork_save_infrun_state (struct fork_info *fp, int clobber_regs) fp->savedregs = regcache_dup (get_current_regcache ()); fp->clobber_regs = clobber_regs; - 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, 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; @@ -302,7 +297,7 @@ fork_save_infrun_state (struct fork_info *fp, int clobber_regs) fp->maxfd = tmp; } /* Allocate array of file positions. */ - fp->filepos = xrealloc (fp->filepos, + fp->filepos = xrealloc (fp->filepos, (fp->maxfd + 1) * sizeof (*fp->filepos)); /* Initialize to -1 (invalid). */ @@ -324,7 +319,7 @@ fork_save_infrun_state (struct fork_info *fp, int clobber_regs) /* 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 @@ -338,7 +333,7 @@ linux_fork_killall (void) 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. */ @@ -356,7 +351,7 @@ linux_fork_killall (void) forks to debug. Delete the exiting one and context-switch to the first available. */ -extern void +void linux_fork_mourn_inferior (void) { /* Wait just one more time to collect the inferior's exit status. @@ -371,8 +366,6 @@ linux_fork_mourn_inferior (void) We need to delete that one from the fork_list, and switch to the next available fork. */ delete_fork (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 @@ -392,19 +385,17 @@ linux_fork_mourn_inferior (void) viable forks to debug. Detach and delete it and context-switch to the first available. */ -extern void -linux_fork_detach (char *args, int from_tty) +void +linux_fork_detach (const char *args, 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 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 @@ -422,71 +413,148 @@ linux_fork_detach (char *args, int from_tty) 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).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, 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_fork_command (char *args, int from_tty) +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 (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); + error (_("No such checkpoint id, %s"), args); if (ptid_equal (ptid, inferior_ptid)) - error (_("Please switch to another fork/checkpoint before deleting the current one")); + 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); - /* Delete process from GDB's inferior list. */ - delete_inferior (ptid_get_pid (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, ptid_get_pid (ptid))) + warning (_("Unable to wait pid %s"), target_pid_to_str (ptid)); + } } static void -detach_fork_command (char *args, int from_tty) +detach_checkpoint_command (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); + error (_("No such checkpoint id, %s"), args); if (ptid_equal (ptid, inferior_ptid)) - error (_("Please switch to another fork before detaching the current one")); + 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) 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. */ +/* Print information about currently known checkpoints. */ static void -info_forks_command (char *arg, int from_tty) +info_checkpoints_command (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; @@ -508,7 +576,7 @@ info_forks_command (char *arg, int from_tty) else { printf_filtered (" "); - pc = fp->pc; + pc = regcache_read_pc (fp->savedregs); } printf_filtered ("%d %s", fp->num, target_pid_to_str (fp->ptid)); if (fp->num == 0) @@ -518,23 +586,17 @@ info_forks_command (char *arg, int from_tty) 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'); @@ -542,31 +604,46 @@ 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). */ +int +linux_fork_checkpointing_p (int pid) +{ + return (checkpointing_pid == pid); +} -static void -restore_detach_fork (void *arg) +/* 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) { - detach_fork = *(int *) arg; + 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; } -static struct cleanup * -save_detach_fork (int *saved_val) +/* Return true if the current inferior is multi-threaded. */ + +static int +inf_has_multiple_threads (void) { - *saved_val = detach_fork; - return make_cleanup (restore_detach_fork, (void *) saved_val); + int count = 0; + + iterate_over_threads (inf_has_multiple_thread_cb, &count); + return (count > 1); } static void @@ -580,28 +657,32 @@ checkpoint_command (char *args, int from_tty) 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; - /* Remove breakpoints, so that they are not inserted - in the forked process. */ - remove_breakpoints (); + 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.")); 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; + + /* Tell linux-nat.c that we're checkpointing this inferior. */ + old_chain = make_cleanup_restore_integer (&checkpointing_pid); + checkpointing_pid = ptid_get_pid (inferior_ptid); + ret = call_function_by_hand (fork_fn, 0, &ret); do_cleanups (old_chain); if (!ret) /* Probably can't happen. */ @@ -609,27 +690,29 @@ checkpoint_command (char *args, int from_tty) 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); if (parent_pid == 0) parent_pid = ptid_get_pid (last_target_ptid); - printf_filtered (_(" gdb says parent = %ld.\n"), + 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); - insert_breakpoints (); + fp->parent_ptid = last_target_ptid; } static void @@ -637,8 +720,6 @@ linux_fork_context (struct fork_info *newfp, int from_tty) { /* Now we attempt to switch processes. */ struct fork_info *oldfp; - ptid_t ptid; - int id, i; gdb_assert (newfp != NULL); @@ -650,43 +731,13 @@ linux_fork_context (struct fork_info *newfp, int from_tty) fork_load_infrun_state (newfp); insert_breakpoints (); - printf_filtered (_("Switching to %s\n"), + 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); + print_stack_frame (get_selected_frame (NULL), 1, SRC_AND_LOC, 1); } -/* 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. */ +/* Switch inferior process (checkpoint) context, by checkpoint id. */ static void restart_command (char *args, int from_tty) { @@ -706,69 +757,36 @@ _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'.")); /* 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.")); }