1 /* GNU/Linux native-dependent code for debugging multiple forks.
3 Copyright (C) 2005, 2006 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 51 Franklin Street, Fifth Floor,
20 Boston, MA 02110-1301, USA. */
27 #include "gdb_assert.h"
28 #include "gdb_string.h"
29 #include "linux-fork.h"
30 #include "linux-nat.h"
32 #include <sys/ptrace.h>
34 #include <sys/param.h>
38 struct fork_info *fork_list;
39 static int highest_fork_num;
41 /* Prevent warning from -Wmissing-prototypes. */
42 extern void _initialize_linux_fork (void);
44 int detach_fork = 1; /* Default behavior is to detach
45 newly forked processes (legacy). */
47 /* Fork list data structure: */
50 struct fork_info *next;
52 int num; /* Convenient handle (GDB fork id) */
53 struct regcache *savedregs; /* Convenient for info fork, saves
54 having to actually switch contexts. */
55 int clobber_regs; /* True if we should restore saved regs. */
56 ULONGEST pc; /* PC for info fork. */
57 off_t *filepos; /* Set of open file descriptors' offsets. */
61 /* Fork list methods: */
66 return (fork_list != NULL);
69 /* Add a fork to internal fork list.
70 Called from linux child_follow_fork. */
72 extern struct fork_info *
77 if (fork_list == NULL && pid != PIDGET (inferior_ptid))
79 /* Special case -- if this is the first fork in the list
80 (the list is hitherto empty), and if this new fork is
81 NOT the current inferior_ptid, then add inferior_ptid
82 first, as a special zeroeth fork id. */
83 highest_fork_num = -1;
84 add_fork (PIDGET (inferior_ptid)); /* safe recursion */
87 fp = XZALLOC (struct fork_info);
88 fp->ptid = ptid_build (pid, pid, 0);
89 fp->num = ++highest_fork_num;
96 free_fork (struct fork_info *fp)
98 /* Notes on step-resume breakpoints: since this is a concern for
99 threads, let's convince ourselves that it's not a concern for
100 forks. There are two ways for a fork_info to be created. First,
101 by the checkpoint command, in which case we're at a gdb prompt
102 and there can't be any step-resume breakpoint. Second, by a fork
103 in the user program, in which case we *may* have stepped into the
104 fork call, but regardless of whether we follow the parent or the
105 child, we will return to the same place and the step-resume
106 breakpoint, if any, will take care of itself as usual. And
107 unlike threads, we do not save a private copy of the step-resume
108 breakpoint -- so we're OK. */
113 regcache_xfree (fp->savedregs);
121 delete_fork (ptid_t ptid)
123 struct fork_info *fp, *fpprev;
127 for (fp = fork_list; fp; fpprev = fp, fp = fp->next)
128 if (ptid_equal (fp->ptid, ptid))
135 fpprev->next = fp->next;
137 fork_list = fp->next;
141 /* Special case: if there is now only one process in the list,
142 and if it is (hopefully!) the current inferior_ptid, then
143 remove it, leaving the list empty -- we're now down to the
144 default case of debugging a single process. */
145 if (fork_list != NULL && fork_list->next == NULL &&
146 ptid_equal (fork_list->ptid, inferior_ptid))
148 /* Last fork -- delete from list and handle as solo process
149 (should be a safe recursion). */
150 delete_fork (inferior_ptid);
154 /* Find a fork_info by matching PTID. */
155 static struct fork_info *
156 find_fork_ptid (ptid_t ptid)
158 struct fork_info *fp;
160 for (fp = fork_list; fp; fp = fp->next)
161 if (ptid_equal (fp->ptid, ptid))
167 /* Find a fork_info by matching ID. */
168 static struct fork_info *
169 find_fork_id (int num)
171 struct fork_info *fp;
173 for (fp = fork_list; fp; fp = fp->next)
180 /* Find a fork_info by matching pid. */
181 extern struct fork_info *
182 find_fork_pid (pid_t pid)
184 struct fork_info *fp;
186 for (fp = fork_list; fp; fp = fp->next)
187 if (pid == ptid_get_pid (fp->ptid))
194 fork_id_to_ptid (int num)
196 struct fork_info *fork = find_fork_id (num);
200 return pid_to_ptid (-1);
204 init_fork_list (void)
206 struct fork_info *fp, *fpnext;
211 for (fp = fork_list; fp; fp = fpnext)
220 /* Fork list <-> gdb interface. */
222 /* Utility function for fork_load/fork_save.
223 Calls lseek in the (current) inferior process. */
226 call_lseek (int fd, off_t offset, int whence)
230 snprintf (&exp[0], sizeof (exp), "lseek (%d, %ld, %d)",
231 fd, (long) offset, whence);
232 return (off_t) parse_and_eval_long (&exp[0]);
235 /* Load infrun state for the fork PTID. */
238 fork_load_infrun_state (struct fork_info *fp)
240 extern void nullify_last_target_wait_ptid ();
243 inferior_ptid = fp->ptid;
245 linux_nat_switch_fork (inferior_ptid);
247 if (fp->savedregs && fp->clobber_regs)
248 regcache_cpy (current_regcache, fp->savedregs);
250 registers_changed ();
251 reinit_frame_cache ();
253 /* We must select a new frame before making any inferior calls to
255 select_frame (get_current_frame ());
257 stop_pc = read_pc ();
258 nullify_last_target_wait_ptid ();
260 /* Now restore the file positions of open file descriptors. */
263 for (i = 0; i <= fp->maxfd; i++)
264 if (fp->filepos[i] != (off_t) -1)
265 call_lseek (i, fp->filepos[i], SEEK_SET);
266 /* NOTE: I can get away with using SEEK_SET and SEEK_CUR because
267 this is native-only. If it ever has to be cross, we'll have
272 /* Save infrun state for the fork PTID.
273 Exported for use by linux child_follow_fork. */
276 fork_save_infrun_state (struct fork_info *fp, int clobber_regs)
278 char path[MAXPATHLEN];
283 regcache_xfree (fp->savedregs);
285 fp->savedregs = regcache_dup (current_regcache);
286 fp->clobber_regs = clobber_regs;
291 /* Now save the 'state' (file position) of all open file descriptors.
292 Unfortunately fork does not take care of that for us... */
293 snprintf (path, MAXPATHLEN, "/proc/%ld/fd", (long) PIDGET (fp->ptid));
294 if ((d = opendir (path)) != NULL)
299 while ((de = readdir (d)) != NULL)
301 /* Count open file descriptors (actually find highest
303 tmp = strtol (&de->d_name[0], NULL, 10);
307 /* Allocate array of file positions. */
308 fp->filepos = xrealloc (fp->filepos,
309 (fp->maxfd + 1) * sizeof (*fp->filepos));
311 /* Initialize to -1 (invalid). */
312 for (tmp = 0; tmp <= fp->maxfd; tmp++)
313 fp->filepos[tmp] = -1;
315 /* Now find actual file positions. */
317 while ((de = readdir (d)) != NULL)
318 if (isdigit (de->d_name[0]))
320 tmp = strtol (&de->d_name[0], NULL, 10);
321 fp->filepos[tmp] = call_lseek (tmp, 0, SEEK_CUR);
328 /* Kill 'em all, let God sort 'em out... */
331 linux_fork_killall (void)
333 /* Walk list and kill every pid. No need to treat the
334 current inferior_ptid as special (we do not return a
335 status for it) -- however any process may be a child
336 or a parent, so may get a SIGCHLD from a previously
337 killed child. Wait them all out. */
338 struct fork_info *fp;
342 for (fp = fork_list; fp; fp = fp->next)
344 pid = PIDGET (fp->ptid);
346 ptrace (PT_KILL, pid, 0, 0);
347 ret = waitpid (pid, &status, 0);
348 /* We might get a SIGCHLD instead of an exit status. This is
349 aggravated by the first kill above - a child has just
350 died. MVS comment cut-and-pasted from linux-nat. */
351 } while (ret == pid && WIFSTOPPED (status));
353 init_fork_list (); /* Clear list, prepare to start fresh. */
356 /* The current inferior_ptid has exited, but there are other viable
357 forks to debug. Delete the exiting one and context-switch to the
361 linux_fork_mourn_inferior (void)
363 /* Wait just one more time to collect the inferior's exit status.
364 Do not check whether this succeeds though, since we may be
365 dealing with a process that we attached to. Such a process will
366 only report its exit status to its original parent. */
369 waitpid (ptid_get_pid (inferior_ptid), &status, 0);
371 /* OK, presumably inferior_ptid is the one who has exited.
372 We need to delete that one from the fork_list, and switch
373 to the next available fork. */
374 delete_fork (inferior_ptid);
376 /* There should still be a fork - if there's only one left,
377 delete_fork won't remove it, because we haven't updated
378 inferior_ptid yet. */
379 gdb_assert (fork_list);
381 fork_load_infrun_state (fork_list);
382 printf_filtered (_("[Switching to %s]\n"),
383 target_pid_to_str (inferior_ptid));
385 /* If there's only one fork, switch back to non-fork mode. */
386 if (fork_list->next == NULL)
387 delete_fork (inferior_ptid);
390 /* Fork list <-> user interface. */
393 delete_fork_command (char *args, int from_tty)
398 error (_("Requires argument (fork/checkpoint id to delete)"));
400 ptid = fork_id_to_ptid (parse_and_eval_long (args));
401 if (ptid_equal (ptid, minus_one_ptid))
402 error (_("No such fork/checkpoint id, %s"), args);
404 if (ptid_equal (ptid, inferior_ptid))
405 error (_("Please switch to another fork/checkpoint before deleting the current one"));
407 if (ptrace (PTRACE_KILL, PIDGET (ptid), 0, 0))
408 error (_("Unable to kill pid %s"), target_tid_to_str (ptid));
411 printf_filtered (_("Killed %s\n"), target_pid_to_str (ptid));
417 detach_fork_command (char *args, int from_tty)
422 error (_("Requires argument (fork id to detach)"));
424 ptid = fork_id_to_ptid (parse_and_eval_long (args));
425 if (ptid_equal (ptid, minus_one_ptid))
426 error (_("No such fork id, %s"), args);
428 if (ptid_equal (ptid, inferior_ptid))
429 error (_("Please switch to another fork before detaching the current one"));
431 if (ptrace (PTRACE_DETACH, PIDGET (ptid), 0, 0))
432 error (_("Unable to detach %s"), target_pid_to_str (ptid));
435 printf_filtered (_("Detached %s\n"), target_pid_to_str (ptid));
440 /* Print information about currently known forks. */
443 info_forks_command (char *arg, int from_tty)
445 struct frame_info *cur_frame;
446 struct symtab_and_line sal;
447 struct symtab *cur_symtab;
448 struct fork_info *fp;
452 for (fp = fork_list; fp; fp = fp->next)
454 if (ptid_equal (fp->ptid, inferior_ptid))
456 printf_filtered ("* ");
461 printf_filtered (" ");
464 printf_filtered ("%d %s", fp->num, target_pid_to_str (fp->ptid));
466 printf_filtered (_(" (main process)"));
467 printf_filtered (_(" at "));
468 deprecated_print_address_numeric (pc, 1, gdb_stdout);
470 sal = find_pc_line (pc, 0);
473 char *tmp = strrchr (sal.symtab->filename, '/');
476 printf_filtered (_(", file %s"), tmp + 1);
478 printf_filtered (_(", file %s"), sal.symtab->filename);
481 printf_filtered (_(", line %d"), sal.line);
482 if (!sal.symtab && !sal.line)
484 struct minimal_symbol *msym;
486 msym = lookup_minimal_symbol_by_pc (pc);
488 printf_filtered (", <%s>", SYMBOL_LINKAGE_NAME (msym));
491 putchar_filtered ('\n');
495 /* Save/restore mode variable 'detach_fork':
496 We need to temporarily take over this mode variable, while
497 preserving the user-specified state, and make sure that it
498 gets restored in case of error.
500 The int pointer that we use comes from the caller, so we can
501 be called more than once (even though currently we don't need to). */
504 restore_detach_fork (void *arg)
506 detach_fork = *(int *) arg;
509 static struct cleanup *
510 save_detach_fork (int *saved_val)
512 *saved_val = detach_fork;
513 return make_cleanup (restore_detach_fork, (void *) saved_val);
517 checkpoint_command (char *args, int from_tty)
519 struct target_waitstatus last_target_waitstatus;
520 ptid_t last_target_ptid;
521 struct value *fork_fn = NULL, *ret;
522 struct fork_info *fp;
524 struct cleanup *old_chain;
526 /* Make this temp var static, 'cause it's used in the error context. */
527 static int temp_detach_fork;
529 /* Make the inferior fork, record its (and gdb's) state. */
531 if (lookup_minimal_symbol ("fork", NULL, NULL) != NULL)
532 fork_fn = find_function_in_inferior ("fork");
534 if (lookup_minimal_symbol ("_fork", NULL, NULL) != NULL)
535 fork_fn = find_function_in_inferior ("fork");
537 error (_("checkpoint: can't find fork function in inferior."));
539 ret = value_from_longest (builtin_type_int, 0);
540 old_chain = save_detach_fork (&temp_detach_fork);
542 ret = call_function_by_hand (fork_fn, 0, &ret);
543 do_cleanups (old_chain);
544 if (!ret) /* Probably can't happen. */
545 error (_("checkpoint: call_function_by_hand returned null."));
547 retpid = value_as_long (ret);
548 get_last_target_status (&last_target_ptid, &last_target_waitstatus);
553 printf_filtered (_("checkpoint: fork returned pid %ld.\n"),
557 parent_pid = ptid_get_lwp (last_target_ptid);
559 parent_pid = ptid_get_pid (last_target_ptid);
560 printf_filtered (_(" gdb says parent = %ld.\n"),
565 fp = find_fork_pid (retpid);
567 error (_("Failed to find new fork"));
568 fork_save_infrun_state (fp, 1);
572 linux_fork_context (struct fork_info *newfp, int from_tty)
574 /* Now we attempt to switch processes. */
575 struct fork_info *oldfp = find_fork_ptid (inferior_ptid);
580 error (_("No such fork/process"));
583 oldfp = add_fork (ptid_get_pid (inferior_ptid));
585 fork_save_infrun_state (oldfp, 1);
586 fork_load_infrun_state (newfp);
588 printf_filtered (_("Switching to %s\n"),
589 target_pid_to_str (inferior_ptid));
591 print_stack_frame (get_selected_frame (NULL), 1, SRC_AND_LOC);
594 /* Switch inferior process (fork) context, by process id. */
596 process_command (char *args, int from_tty)
598 struct fork_info *fp;
601 error (_("Requires argument (process id to switch to)"));
603 if ((fp = find_fork_pid (parse_and_eval_long (args))) == NULL)
604 error (_("Not found: process id %s"), args);
606 linux_fork_context (fp, from_tty);
609 /* Switch inferior process (fork) context, by fork id. */
611 fork_command (char *args, int from_tty)
613 struct fork_info *fp;
616 error (_("Requires argument (fork id to switch to)"));
618 if ((fp = find_fork_id (parse_and_eval_long (args))) == NULL)
619 error (_("Not found: fork id %s"), args);
621 linux_fork_context (fp, from_tty);
624 /* Switch inferior process (fork) context, by checkpoint id. */
626 restart_command (char *args, int from_tty)
628 struct fork_info *fp;
631 error (_("Requires argument (checkpoint id to restart)"));
633 if ((fp = find_fork_id (parse_and_eval_long (args))) == NULL)
634 error (_("Not found: checkpoint id %s"), args);
636 linux_fork_context (fp, from_tty);
640 _initialize_linux_fork (void)
644 /* Set/show detach-on-fork: user-settable mode. */
646 add_setshow_boolean_cmd ("detach-on-fork", class_obscure, &detach_fork, _("\
647 Set whether gdb will detach the child of a fork."), _("\
648 Show whether gdb will detach the child of a fork."), _("\
649 Tells gdb whether to detach the child of a fork."),
650 NULL, NULL, &setlist, &showlist);
652 /* Set/show restart-auto-finish: user-settable count. Causes the
653 first "restart" of a fork to do some number of "finish" commands
654 before returning to user.
656 Useful because otherwise the virgin fork process will be stopped
657 somewhere in the un-interesting fork system call. */
659 /* Checkpoint command: create a fork of the inferior process
660 and set it aside for later debugging. */
662 add_com ("checkpoint", class_obscure, checkpoint_command, _("\
663 Fork a duplicate process (experimental)."));
665 /* Restart command: restore the context of a specified fork
666 process. May be used for "program forks" as well as for
667 "debugger forks" (checkpoints). */
669 add_com ("restart", class_obscure, restart_command, _("\
670 restart <n>: restore program context from a checkpoint.\n\
671 Argument 'n' is checkpoint ID, as displayed by 'info checkpoints'."));
673 /* Delete-checkpoint command: kill the process and remove it from
676 add_com ("delete-checkpoint", class_obscure, delete_fork_command, _("\
677 Delete a fork/checkpoint (experimental)."));
679 /* Detach-checkpoint command: release the process to run independantly,
680 and remove it from the fork list. */
682 add_com ("detach-checkpoint", class_obscure, detach_fork_command, _("\
683 Detach from a fork/checkpoint (experimental)."));
685 /* Info checkpoints command: list all forks/checkpoints
686 currently under gdb's control. */
688 add_info ("checkpoints", info_forks_command,
689 _("IDs of currently known forks/checkpoints."));
691 /* Command aliases (let "fork" and "checkpoint" be used
694 add_com_alias ("delete-fork", "delete-checkpoint", class_obscure, 1);
695 add_com_alias ("detach-fork", "detach-checkpoint", class_obscure, 1);
696 add_info_alias ("forks", "checkpoints", 0);
698 /* "fork <n>" (by analogy to "thread <n>"). */
699 add_com ("fork", class_obscure, fork_command, _("\
700 fork <n>: Switch between forked processes.\n\
701 Argument 'n' is fork ID, as displayed by 'info forks'."));
703 /* "process <proc id>" as opposed to "fork <fork id>". */
704 add_com ("process", class_obscure, process_command, _("\
705 process <pid>: Switch between forked processes.\n\
706 Argument 'pid' is process ID, as displayed by 'info forks' or 'shell ps'."));