1 /* GNU/Linux native-dependent code for debugging multiple forks.
3 Copyright (C) 2005, 2006, 2007, 2008 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 3 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, see <http://www.gnu.org/licenses/>. */
26 #include "gdb_assert.h"
27 #include "gdb_string.h"
28 #include "linux-fork.h"
29 #include "linux-nat.h"
31 #include <sys/ptrace.h>
33 #include <sys/param.h>
34 #include "gdb_dirent.h"
37 struct fork_info
*fork_list
;
38 static int highest_fork_num
;
40 /* Prevent warning from -Wmissing-prototypes. */
41 extern void _initialize_linux_fork (void);
43 int detach_fork
= 1; /* Default behavior is to detach
44 newly forked processes (legacy). */
46 /* Fork list data structure: */
49 struct fork_info
*next
;
51 int num
; /* Convenient handle (GDB fork id) */
52 struct regcache
*savedregs
; /* Convenient for info fork, saves
53 having to actually switch contexts. */
54 int clobber_regs
; /* True if we should restore saved regs. */
55 ULONGEST pc
; /* PC for info fork. */
56 off_t
*filepos
; /* Set of open file descriptors' offsets. */
60 /* Fork list methods: */
65 return (fork_list
!= NULL
);
68 /* Add a fork to internal fork list.
69 Called from linux child_follow_fork. */
71 extern struct fork_info
*
76 if (fork_list
== NULL
&& pid
!= PIDGET (inferior_ptid
))
78 /* Special case -- if this is the first fork in the list
79 (the list is hitherto empty), and if this new fork is
80 NOT the current inferior_ptid, then add inferior_ptid
81 first, as a special zeroeth fork id. */
82 highest_fork_num
= -1;
83 add_fork (PIDGET (inferior_ptid
)); /* safe recursion */
86 fp
= XZALLOC (struct fork_info
);
87 fp
->ptid
= ptid_build (pid
, pid
, 0);
88 fp
->num
= ++highest_fork_num
;
95 free_fork (struct fork_info
*fp
)
97 /* Notes on step-resume breakpoints: since this is a concern for
98 threads, let's convince ourselves that it's not a concern for
99 forks. There are two ways for a fork_info to be created. First,
100 by the checkpoint command, in which case we're at a gdb prompt
101 and there can't be any step-resume breakpoint. Second, by a fork
102 in the user program, in which case we *may* have stepped into the
103 fork call, but regardless of whether we follow the parent or the
104 child, we will return to the same place and the step-resume
105 breakpoint, if any, will take care of itself as usual. And
106 unlike threads, we do not save a private copy of the step-resume
107 breakpoint -- so we're OK. */
112 regcache_xfree (fp
->savedregs
);
120 delete_fork (ptid_t ptid
)
122 struct fork_info
*fp
, *fpprev
;
126 for (fp
= fork_list
; fp
; fpprev
= fp
, fp
= fp
->next
)
127 if (ptid_equal (fp
->ptid
, ptid
))
134 fpprev
->next
= fp
->next
;
136 fork_list
= fp
->next
;
140 /* Special case: if there is now only one process in the list,
141 and if it is (hopefully!) the current inferior_ptid, then
142 remove it, leaving the list empty -- we're now down to the
143 default case of debugging a single process. */
144 if (fork_list
!= NULL
&& fork_list
->next
== NULL
&&
145 ptid_equal (fork_list
->ptid
, inferior_ptid
))
147 /* Last fork -- delete from list and handle as solo process
148 (should be a safe recursion). */
149 delete_fork (inferior_ptid
);
153 /* Find a fork_info by matching PTID. */
154 static struct fork_info
*
155 find_fork_ptid (ptid_t ptid
)
157 struct fork_info
*fp
;
159 for (fp
= fork_list
; fp
; fp
= fp
->next
)
160 if (ptid_equal (fp
->ptid
, ptid
))
166 /* Find a fork_info by matching ID. */
167 static struct fork_info
*
168 find_fork_id (int num
)
170 struct fork_info
*fp
;
172 for (fp
= fork_list
; fp
; fp
= fp
->next
)
179 /* Find a fork_info by matching pid. */
180 extern struct fork_info
*
181 find_fork_pid (pid_t pid
)
183 struct fork_info
*fp
;
185 for (fp
= fork_list
; fp
; fp
= fp
->next
)
186 if (pid
== ptid_get_pid (fp
->ptid
))
193 fork_id_to_ptid (int num
)
195 struct fork_info
*fork
= find_fork_id (num
);
199 return pid_to_ptid (-1);
203 init_fork_list (void)
205 struct fork_info
*fp
, *fpnext
;
210 for (fp
= fork_list
; fp
; fp
= fpnext
)
213 delete_inferior (ptid_get_pid (fp
->ptid
));
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 (get_current_regcache (), fp
->savedregs
);
250 registers_changed ();
251 reinit_frame_cache ();
253 stop_pc
= read_pc ();
254 nullify_last_target_wait_ptid ();
256 /* Now restore the file positions of open file descriptors. */
259 for (i
= 0; i
<= fp
->maxfd
; i
++)
260 if (fp
->filepos
[i
] != (off_t
) -1)
261 call_lseek (i
, fp
->filepos
[i
], SEEK_SET
);
262 /* NOTE: I can get away with using SEEK_SET and SEEK_CUR because
263 this is native-only. If it ever has to be cross, we'll have
268 /* Save infrun state for the fork PTID.
269 Exported for use by linux child_follow_fork. */
272 fork_save_infrun_state (struct fork_info
*fp
, int clobber_regs
)
274 char path
[MAXPATHLEN
];
279 regcache_xfree (fp
->savedregs
);
281 fp
->savedregs
= regcache_dup (get_current_regcache ());
282 fp
->clobber_regs
= clobber_regs
;
287 /* Now save the 'state' (file position) of all open file descriptors.
288 Unfortunately fork does not take care of that for us... */
289 snprintf (path
, MAXPATHLEN
, "/proc/%ld/fd", (long) PIDGET (fp
->ptid
));
290 if ((d
= opendir (path
)) != NULL
)
295 while ((de
= readdir (d
)) != NULL
)
297 /* Count open file descriptors (actually find highest
299 tmp
= strtol (&de
->d_name
[0], NULL
, 10);
303 /* Allocate array of file positions. */
304 fp
->filepos
= xrealloc (fp
->filepos
,
305 (fp
->maxfd
+ 1) * sizeof (*fp
->filepos
));
307 /* Initialize to -1 (invalid). */
308 for (tmp
= 0; tmp
<= fp
->maxfd
; tmp
++)
309 fp
->filepos
[tmp
] = -1;
311 /* Now find actual file positions. */
313 while ((de
= readdir (d
)) != NULL
)
314 if (isdigit (de
->d_name
[0]))
316 tmp
= strtol (&de
->d_name
[0], NULL
, 10);
317 fp
->filepos
[tmp
] = call_lseek (tmp
, 0, SEEK_CUR
);
324 /* Kill 'em all, let God sort 'em out... */
327 linux_fork_killall (void)
329 /* Walk list and kill every pid. No need to treat the
330 current inferior_ptid as special (we do not return a
331 status for it) -- however any process may be a child
332 or a parent, so may get a SIGCHLD from a previously
333 killed child. Wait them all out. */
334 struct fork_info
*fp
;
338 for (fp
= fork_list
; fp
; fp
= fp
->next
)
340 pid
= PIDGET (fp
->ptid
);
342 /* Use SIGKILL instead of PTRACE_KILL because the former works even
343 if the thread is running, while the later doesn't. */
345 ret
= waitpid (pid
, &status
, 0);
346 /* We might get a SIGCHLD instead of an exit status. This is
347 aggravated by the first kill above - a child has just
348 died. MVS comment cut-and-pasted from linux-nat. */
349 } while (ret
== pid
&& WIFSTOPPED (status
));
351 init_fork_list (); /* Clear list, prepare to start fresh. */
354 /* The current inferior_ptid has exited, but there are other viable
355 forks to debug. Delete the exiting one and context-switch to the
359 linux_fork_mourn_inferior (void)
361 /* Wait just one more time to collect the inferior's exit status.
362 Do not check whether this succeeds though, since we may be
363 dealing with a process that we attached to. Such a process will
364 only report its exit status to its original parent. */
367 waitpid (ptid_get_pid (inferior_ptid
), &status
, 0);
369 /* OK, presumably inferior_ptid is the one who has exited.
370 We need to delete that one from the fork_list, and switch
371 to the next available fork. */
372 delete_fork (inferior_ptid
);
373 /* Delete process from GDB's inferior list. */
374 delete_inferior (ptid_get_pid (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
));
414 /* Delete process from GDB's inferior list. */
415 delete_inferior (ptid_get_pid (ptid
));
419 detach_fork_command (char *args
, int from_tty
)
424 error (_("Requires argument (fork id to detach)"));
426 ptid
= fork_id_to_ptid (parse_and_eval_long (args
));
427 if (ptid_equal (ptid
, minus_one_ptid
))
428 error (_("No such fork id, %s"), args
);
430 if (ptid_equal (ptid
, inferior_ptid
))
431 error (_("Please switch to another fork before detaching the current one"));
433 if (ptrace (PTRACE_DETACH
, PIDGET (ptid
), 0, 0))
434 error (_("Unable to detach %s"), target_pid_to_str (ptid
));
437 printf_filtered (_("Detached %s\n"), target_pid_to_str (ptid
));
440 /* Delete process from GDB's process table. */
441 detach_inferior (ptid_get_pid (ptid
));
444 /* Print information about currently known forks. */
447 info_forks_command (char *arg
, int from_tty
)
449 struct frame_info
*cur_frame
;
450 struct symtab_and_line sal
;
451 struct symtab
*cur_symtab
;
452 struct fork_info
*fp
;
456 struct fork_info
*printed
= NULL
;
459 requested
= (int) parse_and_eval_long (arg
);
461 for (fp
= fork_list
; fp
; fp
= fp
->next
)
463 if (requested
> 0 && fp
->num
!= requested
)
467 if (ptid_equal (fp
->ptid
, inferior_ptid
))
469 printf_filtered ("* ");
474 printf_filtered (" ");
477 printf_filtered ("%d %s", fp
->num
, target_pid_to_str (fp
->ptid
));
479 printf_filtered (_(" (main process)"));
480 printf_filtered (_(" at "));
481 fputs_filtered (paddress (pc
), gdb_stdout
);
483 sal
= find_pc_line (pc
, 0);
486 char *tmp
= strrchr (sal
.symtab
->filename
, '/');
489 printf_filtered (_(", file %s"), tmp
+ 1);
491 printf_filtered (_(", file %s"), sal
.symtab
->filename
);
494 printf_filtered (_(", line %d"), sal
.line
);
495 if (!sal
.symtab
&& !sal
.line
)
497 struct minimal_symbol
*msym
;
499 msym
= lookup_minimal_symbol_by_pc (pc
);
501 printf_filtered (", <%s>", SYMBOL_LINKAGE_NAME (msym
));
504 putchar_filtered ('\n');
509 printf_filtered (_("No fork number %d.\n"), requested
);
511 printf_filtered (_("No forks.\n"));
515 /* Save/restore mode variable 'detach_fork':
516 We need to temporarily take over this mode variable, while
517 preserving the user-specified state, and make sure that it
518 gets restored in case of error.
520 The int pointer that we use comes from the caller, so we can
521 be called more than once (even though currently we don't need to). */
524 restore_detach_fork (void *arg
)
526 detach_fork
= *(int *) arg
;
529 static struct cleanup
*
530 save_detach_fork (int *saved_val
)
532 *saved_val
= detach_fork
;
533 return make_cleanup (restore_detach_fork
, (void *) saved_val
);
537 checkpoint_command (char *args
, int from_tty
)
539 struct objfile
*fork_objf
;
540 struct gdbarch
*gdbarch
;
541 struct target_waitstatus last_target_waitstatus
;
542 ptid_t last_target_ptid
;
543 struct value
*fork_fn
= NULL
, *ret
;
544 struct fork_info
*fp
;
546 struct cleanup
*old_chain
;
548 /* Make this temp var static, 'cause it's used in the error context. */
549 static int temp_detach_fork
;
551 /* Remove breakpoints, so that they are not inserted
552 in the forked process. */
553 remove_breakpoints ();
555 /* Make the inferior fork, record its (and gdb's) state. */
557 if (lookup_minimal_symbol ("fork", NULL
, NULL
) != NULL
)
558 fork_fn
= find_function_in_inferior ("fork", &fork_objf
);
560 if (lookup_minimal_symbol ("_fork", NULL
, NULL
) != NULL
)
561 fork_fn
= find_function_in_inferior ("fork", &fork_objf
);
563 error (_("checkpoint: can't find fork function in inferior."));
565 gdbarch
= get_objfile_arch (fork_objf
);
566 ret
= value_from_longest (builtin_type (gdbarch
)->builtin_int
, 0);
567 old_chain
= save_detach_fork (&temp_detach_fork
);
569 ret
= call_function_by_hand (fork_fn
, 0, &ret
);
570 do_cleanups (old_chain
);
571 if (!ret
) /* Probably can't happen. */
572 error (_("checkpoint: call_function_by_hand returned null."));
574 retpid
= value_as_long (ret
);
575 get_last_target_status (&last_target_ptid
, &last_target_waitstatus
);
580 printf_filtered (_("checkpoint: fork returned pid %ld.\n"),
584 parent_pid
= ptid_get_lwp (last_target_ptid
);
586 parent_pid
= ptid_get_pid (last_target_ptid
);
587 printf_filtered (_(" gdb says parent = %ld.\n"),
592 fp
= find_fork_pid (retpid
);
594 error (_("Failed to find new fork"));
595 fork_save_infrun_state (fp
, 1);
596 insert_breakpoints ();
600 linux_fork_context (struct fork_info
*newfp
, int from_tty
)
602 /* Now we attempt to switch processes. */
603 struct fork_info
*oldfp
= find_fork_ptid (inferior_ptid
);
608 error (_("No such fork/process"));
611 oldfp
= add_fork (ptid_get_pid (inferior_ptid
));
613 fork_save_infrun_state (oldfp
, 1);
614 remove_breakpoints ();
615 fork_load_infrun_state (newfp
);
616 insert_breakpoints ();
618 printf_filtered (_("Switching to %s\n"),
619 target_pid_to_str (inferior_ptid
));
621 print_stack_frame (get_selected_frame (NULL
), 1, SRC_AND_LOC
);
624 /* Switch inferior process (fork) context, by process id. */
626 process_command (char *args
, int from_tty
)
628 struct fork_info
*fp
;
631 error (_("Requires argument (process id to switch to)"));
633 if ((fp
= find_fork_pid (parse_and_eval_long (args
))) == NULL
)
634 error (_("Not found: process id %s"), args
);
636 linux_fork_context (fp
, from_tty
);
639 /* Switch inferior process (fork) context, by fork id. */
641 fork_command (char *args
, int from_tty
)
643 struct fork_info
*fp
;
646 error (_("Requires argument (fork id to switch to)"));
648 if ((fp
= find_fork_id (parse_and_eval_long (args
))) == NULL
)
649 error (_("Not found: fork id %s"), args
);
651 linux_fork_context (fp
, from_tty
);
654 /* Switch inferior process (fork) context, by checkpoint id. */
656 restart_command (char *args
, int from_tty
)
658 struct fork_info
*fp
;
661 error (_("Requires argument (checkpoint id to restart)"));
663 if ((fp
= find_fork_id (parse_and_eval_long (args
))) == NULL
)
664 error (_("Not found: checkpoint id %s"), args
);
666 linux_fork_context (fp
, from_tty
);
670 _initialize_linux_fork (void)
674 /* Set/show detach-on-fork: user-settable mode. */
676 add_setshow_boolean_cmd ("detach-on-fork", class_obscure
, &detach_fork
, _("\
677 Set whether gdb will detach the child of a fork."), _("\
678 Show whether gdb will detach the child of a fork."), _("\
679 Tells gdb whether to detach the child of a fork."),
680 NULL
, NULL
, &setlist
, &showlist
);
682 /* Set/show restart-auto-finish: user-settable count. Causes the
683 first "restart" of a fork to do some number of "finish" commands
684 before returning to user.
686 Useful because otherwise the virgin fork process will be stopped
687 somewhere in the un-interesting fork system call. */
689 /* Checkpoint command: create a fork of the inferior process
690 and set it aside for later debugging. */
692 add_com ("checkpoint", class_obscure
, checkpoint_command
, _("\
693 Fork a duplicate process (experimental)."));
695 /* Restart command: restore the context of a specified fork
696 process. May be used for "program forks" as well as for
697 "debugger forks" (checkpoints). */
699 add_com ("restart", class_obscure
, restart_command
, _("\
700 restart <n>: restore program context from a checkpoint.\n\
701 Argument 'n' is checkpoint ID, as displayed by 'info checkpoints'."));
703 /* Delete checkpoint command: kill the process and remove it from
706 add_cmd ("checkpoint", class_obscure
, delete_fork_command
, _("\
707 Delete a fork/checkpoint (experimental)."),
710 /* Detach checkpoint command: release the process to run independently,
711 and remove it from the fork list. */
713 add_cmd ("checkpoint", class_obscure
, detach_fork_command
, _("\
714 Detach from a fork/checkpoint (experimental)."),
717 /* Info checkpoints command: list all forks/checkpoints
718 currently under gdb's control. */
720 add_info ("checkpoints", info_forks_command
,
721 _("IDs of currently known forks/checkpoints."));
723 /* Command aliases (let "fork" and "checkpoint" be used
726 add_alias_cmd ("fork", "checkpoint", class_obscure
, 1, &deletelist
);
727 add_alias_cmd ("fork", "checkpoint", class_obscure
, 1, &detachlist
);
728 add_info_alias ("forks", "checkpoints", 0);
730 /* "fork <n>" (by analogy to "thread <n>"). */
731 add_com ("fork", class_obscure
, fork_command
, _("\
732 fork <n>: Switch between forked processes.\n\
733 Argument 'n' is fork ID, as displayed by 'info forks'."));
735 /* "process <proc id>" as opposed to "fork <fork id>". */
736 add_com ("process", class_obscure
, process_command
, _("\
737 process <pid>: Switch between forked processes.\n\
738 Argument 'pid' is process ID, as displayed by 'info forks' or 'shell ps'."));