URL
https://opencores.org/ocsvn/openrisc_me/openrisc_me/trunk
Subversion Repositories openrisc_me
[/] [openrisc/] [trunk/] [gnu-src/] [gdb-6.8/] [gdb/] [linux-fork.c] - Rev 288
Go to most recent revision | Compare with Previous | Blame | View Log
/* GNU/Linux native-dependent code for debugging multiple forks. 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 3 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, see <http://www.gnu.org/licenses/>. */ #include "defs.h" #include "inferior.h" #include "regcache.h" #include "gdbcmd.h" #include "infcall.h" #include "gdb_assert.h" #include "gdb_string.h" #include "linux-fork.h" #include "linux-nat.h" #include <sys/ptrace.h> #include "gdb_wait.h" #include <sys/param.h> #include "gdb_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 = ptid_build (pid, pid, 0); 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; inferior_ptid = fp->ptid; linux_nat_switch_fork (inferior_ptid); if (fp->savedregs && fp->clobber_regs) 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->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 (get_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. */ struct fork_info *fp; pid_t pid, ret; int status; for (fp = fork_list; fp; fp = fp->next) { pid = PIDGET (fp->ptid); do { ptrace (PT_KILL, pid, 0, 0); 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 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); /* 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. */ 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, 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); } 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, 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); } /* 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; 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 ("* "); 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 ")); fputs_filtered (paddress (pc), 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'); } 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': 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); fork_load_infrun_state (newfp); 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_cmd ("checkpoint", class_obscure, delete_fork_command, _("\ Delete a fork/checkpoint (experimental)."), &deletelist); /* 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)."), &detachlist); /* 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 <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'.")); }
Go to most recent revision | Compare with Previous | Blame | View Log