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_string.h"
28 #include "linux-fork.h"
30 #include <sys/ptrace.h>
32 #include <sys/param.h>
36 struct fork_info
*fork_list
;
37 static int highest_fork_num
;
39 /* Prevent warning from -Wmissing-prototypes. */
40 extern void _initialize_linux_fork (void);
42 int detach_fork
= 1; /* Default behavior is to detach
43 newly forked processes (legacy). */
45 /* Fork list data structure: */
48 struct fork_info
*next
;
50 int num
; /* Convenient handle (GDB fork id) */
51 struct regcache
*savedregs
; /* Convenient for info fork, saves
52 having to actually switch contexts. */
53 int clobber_regs
; /* True if we should restore saved regs. */
54 ULONGEST pc
; /* PC for info fork. */
55 off_t
*filepos
; /* Set of open file descriptors' offsets. */
59 /* Fork list methods: */
64 return (fork_list
!= NULL
);
67 /* Add a fork to internal fork list.
68 Called from linux child_follow_fork. */
70 extern struct fork_info
*
75 if (fork_list
== NULL
&&
76 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
= pid_to_ptid (pid
);
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
)
219 /* Fork list <-> gdb interface. */
221 /* Utility function for fork_load/fork_save.
222 Calls lseek in the (current) inferior process. */
225 call_lseek (int fd
, off_t offset
, int whence
)
229 snprintf (&exp
[0], sizeof (exp
), "lseek (%d, %ld, %d)",
230 fd
, (long) offset
, whence
);
231 return (off_t
) parse_and_eval_long (&exp
[0]);
234 /* Load infrun state for the fork PTID. */
237 fork_load_infrun_state (struct fork_info
*fp
)
239 extern void nullify_last_target_wait_ptid ();
242 if (fp
->savedregs
&& fp
->clobber_regs
)
243 regcache_cpy (current_regcache
, fp
->savedregs
);
245 nullify_last_target_wait_ptid ();
247 /* Now restore the file positions of open file descriptors. */
250 for (i
= 0; i
<= fp
->maxfd
; i
++)
251 if (fp
->filepos
[i
] != (off_t
) -1)
252 call_lseek (i
, fp
->filepos
[i
], SEEK_SET
);
253 /* NOTE: I can get away with using SEEK_SET and SEEK_CUR because
254 this is native-only. If it ever has to be cross, we'll have
259 /* Save infrun state for the fork PTID.
260 Exported for use by linux child_follow_fork. */
263 fork_save_infrun_state (struct fork_info
*fp
, int clobber_regs
)
265 char path
[MAXPATHLEN
];
270 regcache_xfree (fp
->savedregs
);
272 fp
->savedregs
= regcache_dup (current_regcache
);
273 fp
->clobber_regs
= clobber_regs
;
278 /* Now save the 'state' (file position) of all open file descriptors.
279 Unfortunately fork does not take care of that for us... */
280 snprintf (path
, MAXPATHLEN
, "/proc/%ld/fd", (long) PIDGET (fp
->ptid
));
281 if ((d
= opendir (path
)) != NULL
)
286 while ((de
= readdir (d
)) != NULL
)
288 /* Count open file descriptors (actually find highest
290 tmp
= strtol (&de
->d_name
[0], NULL
, 10);
294 /* Allocate array of file positions. */
295 fp
->filepos
= xrealloc (fp
->filepos
,
296 (fp
->maxfd
+ 1) * sizeof (*fp
->filepos
));
298 /* Initialize to -1 (invalid). */
299 for (tmp
= 0; tmp
<= fp
->maxfd
; tmp
++)
300 fp
->filepos
[tmp
] = -1;
302 /* Now find actual file positions. */
304 while ((de
= readdir (d
)) != NULL
)
305 if (isdigit (de
->d_name
[0]))
307 tmp
= strtol (&de
->d_name
[0], NULL
, 10);
308 fp
->filepos
[tmp
] = call_lseek (tmp
, 0, SEEK_CUR
);
315 /* Kill 'em all, let God sort 'em out... */
318 linux_fork_killall (void)
320 /* Walk list and kill every pid. No need to treat the
321 current inferior_ptid as special (we do not return a
322 status for it) -- however any process may be a child
323 or a parent, so may get a SIGCHLD from a previously
324 killed child. Wait them all out. */
329 pid
= PIDGET (fork_list
->ptid
);
331 ptrace (PT_KILL
, pid
, 0, 0);
332 ret
= waitpid (pid
, &status
, 0);
333 } while (ret
== pid
&& WIFSTOPPED (status
));
334 delete_fork (fork_list
->ptid
);
335 } while (fork_list
!= NULL
);
338 /* The current inferior_ptid has exited, but there are other viable
339 forks to debug. Delete the exiting one and context-switch to the
343 linux_fork_mourn_inferior (void)
345 /* Wait just one more time to collect the inferior's exit status.
346 Do not check whether this succeeds though, since we may be
347 dealing with a process that we attached to. Such a process will
348 only report its exit status to its original parent. */
351 waitpid (ptid_get_pid (inferior_ptid
), &status
, 0);
353 /* OK, presumably inferior_ptid is the one who has exited.
354 We need to delete that one from the fork_list, and switch
355 to the next available fork. */
356 delete_fork (inferior_ptid
);
357 if (fork_list
) /* Paranoia, shouldn't happen. */
359 inferior_ptid
= fork_list
[0].ptid
;
360 printf_filtered (_("[Switching to %s]\n"),
361 target_pid_to_str (inferior_ptid
));
365 /* Fork list <-> user interface. */
368 delete_fork_command (char *args
, int from_tty
)
373 error (_("Requires argument (fork/checkpoint id to delete)"));
375 ptid
= fork_id_to_ptid (parse_and_eval_long (args
));
376 if (ptid_equal (ptid
, minus_one_ptid
))
377 error (_("No such fork/checkpoint id, %s"), args
);
379 if (ptid_equal (ptid
, inferior_ptid
))
380 error (_("Please switch to another fork/checkpoint before deleting the current one"));
382 if (ptrace (PTRACE_KILL
, PIDGET (ptid
), 0, 0))
383 error (_("Unable to kill pid %s"), target_tid_to_str (ptid
));
386 printf_filtered (_("Killed %s\n"), target_pid_to_str (ptid
));
392 detach_fork_command (char *args
, int from_tty
)
397 error (_("Requires argument (fork id to detach)"));
399 ptid
= fork_id_to_ptid (parse_and_eval_long (args
));
400 if (ptid_equal (ptid
, minus_one_ptid
))
401 error (_("No such fork id, %s"), args
);
403 if (ptid_equal (ptid
, inferior_ptid
))
404 error (_("Please switch to another fork before detaching the current one"));
406 if (ptrace (PTRACE_DETACH
, PIDGET (ptid
), 0, 0))
407 error (_("Unable to detach %s"), target_pid_to_str (ptid
));
410 printf_filtered (_("Detached %s\n"), target_pid_to_str (ptid
));
415 /* Print information about currently known forks. */
418 info_forks_command (char *arg
, int from_tty
)
420 struct frame_info
*cur_frame
;
421 struct symtab_and_line sal
;
422 struct symtab
*cur_symtab
;
423 struct fork_info
*fp
;
427 for (fp
= fork_list
; fp
; fp
= fp
->next
)
429 if (ptid_equal (fp
->ptid
, inferior_ptid
))
431 printf_filtered ("* ");
436 printf_filtered (" ");
439 printf_filtered ("%d %s", fp
->num
, target_pid_to_str (fp
->ptid
));
441 printf_filtered (_(" (main process)"));
442 printf_filtered (_(" at "));
443 deprecated_print_address_numeric (pc
, 1, gdb_stdout
);
445 sal
= find_pc_line (pc
, 0);
448 char *tmp
= strrchr (sal
.symtab
->filename
, '/');
451 printf_filtered (_(", file %s"), tmp
+ 1);
453 printf_filtered (_(", file %s"), sal
.symtab
->filename
);
456 printf_filtered (_(", line %d"), sal
.line
);
457 if (!sal
.symtab
&& !sal
.line
)
459 struct minimal_symbol
*msym
;
461 msym
= lookup_minimal_symbol_by_pc (pc
);
463 printf_filtered (", <%s>", SYMBOL_LINKAGE_NAME (msym
));
466 putchar_filtered ('\n');
470 /* Save/restore mode variable 'detach_fork':
471 We need to temporarily take over this mode variable, while
472 preserving the user-specified state, and make sure that it
473 gets restored in case of error.
475 The int pointer that we use comes from the caller, so we can
476 be called more than once (even though currently we don't need to). */
479 restore_detach_fork (void *arg
)
481 detach_fork
= *(int *) arg
;
484 static struct cleanup
*
485 save_detach_fork (int *saved_val
)
487 *saved_val
= detach_fork
;
488 return make_cleanup (restore_detach_fork
, (void *) saved_val
);
492 checkpoint_command (char *args
, int from_tty
)
494 struct target_waitstatus last_target_waitstatus
;
495 ptid_t last_target_ptid
;
496 struct value
*fork_fn
= NULL
, *ret
;
497 struct fork_info
*fp
;
499 struct cleanup
*old_chain
;
501 /* Make this temp var static, 'cause it's used in the error context. */
502 static int temp_detach_fork
;
504 /* Make the inferior fork, record its (and gdb's) state. */
506 if (lookup_minimal_symbol ("fork", NULL
, NULL
) != NULL
)
507 fork_fn
= find_function_in_inferior ("fork");
509 if (lookup_minimal_symbol ("_fork", NULL
, NULL
) != NULL
)
510 fork_fn
= find_function_in_inferior ("fork");
512 error (_("checkpoint: can't find fork function in inferior."));
514 ret
= value_from_longest (builtin_type_int
, 0);
515 old_chain
= save_detach_fork (&temp_detach_fork
);
517 ret
= call_function_by_hand (fork_fn
, 0, &ret
);
518 do_cleanups (old_chain
);
519 if (!ret
) /* Probably can't happen. */
520 error (_("checkpoint: call_function_by_hand returned null."));
522 retpid
= value_as_long (ret
);
523 get_last_target_status (&last_target_ptid
, &last_target_waitstatus
);
528 printf_filtered (_("checkpoint: fork returned pid %ld.\n"),
532 parent_pid
= ptid_get_lwp (last_target_ptid
);
534 parent_pid
= ptid_get_pid (last_target_ptid
);
535 printf_filtered (_(" gdb says parent = %ld.\n"),
540 fp
= find_fork_pid (retpid
);
542 error (_("Failed to find new fork"));
543 fork_save_infrun_state (fp
, 1);
547 linux_fork_context (struct fork_info
*newfp
, int from_tty
)
549 /* Now we attempt to switch processes. */
550 struct fork_info
*oldfp
= find_fork_ptid (inferior_ptid
);
555 error (_("No such fork/process"));
559 oldfp
= add_fork (ptid_get_pid (inferior_ptid
));
562 fork_save_infrun_state (oldfp
, 1);
563 inferior_ptid
= newfp
->ptid
;
564 fork_load_infrun_state (newfp
);
565 registers_changed ();
566 reinit_frame_cache ();
567 stop_pc
= read_pc ();
568 select_frame (get_current_frame ());
570 printf_filtered (_("Switching to %s\n"),
571 target_pid_to_str (inferior_ptid
));
573 print_stack_frame (get_selected_frame (NULL
), 1, SRC_AND_LOC
);
576 /* Switch inferior process (fork) context, by process id. */
578 process_command (char *args
, int from_tty
)
580 struct fork_info
*fp
;
583 error (_("Requires argument (process id to switch to)"));
585 if ((fp
= find_fork_pid (parse_and_eval_long (args
))) == NULL
)
586 error (_("Not found: process id %s"), args
);
588 linux_fork_context (fp
, from_tty
);
591 /* Switch inferior process (fork) context, by fork id. */
593 fork_command (char *args
, int from_tty
)
595 struct fork_info
*fp
;
598 error (_("Requires argument (fork id to switch to)"));
600 if ((fp
= find_fork_id (parse_and_eval_long (args
))) == NULL
)
601 error (_("Not found: fork id %s"), args
);
603 linux_fork_context (fp
, from_tty
);
606 /* Switch inferior process (fork) context, by checkpoint id. */
608 restart_command (char *args
, int from_tty
)
610 struct fork_info
*fp
;
613 error (_("Requires argument (checkpoint id to restart)"));
615 if ((fp
= find_fork_id (parse_and_eval_long (args
))) == NULL
)
616 error (_("Not found: checkpoint id %s"), args
);
618 linux_fork_context (fp
, from_tty
);
622 _initialize_linux_fork (void)
626 /* Set/show detach-on-fork: user-settable mode. */
628 add_setshow_boolean_cmd ("detach-on-fork", class_obscure
, &detach_fork
, _("\
629 Set whether gdb will detach the child of a fork."), _("\
630 Show whether gdb will detach the child of a fork."), _("\
631 Tells gdb whether to detach the child of a fork."),
632 NULL
, NULL
, &setlist
, &showlist
);
634 /* Set/show restart-auto-finish: user-settable count. Causes the
635 first "restart" of a fork to do some number of "finish" commands
636 before returning to user.
638 Useful because otherwise the virgin fork process will be stopped
639 somewhere in the un-interesting fork system call. */
641 /* Checkpoint command: create a fork of the inferior process
642 and set it aside for later debugging. */
644 add_com ("checkpoint", class_obscure
, checkpoint_command
, _("\
645 Fork a duplicate process (experimental)."));
647 /* Restart command: restore the context of a specified fork
648 process. May be used for "program forks" as well as for
649 "debugger forks" (checkpoints). */
651 add_com ("restart", class_obscure
, restart_command
, _("\
652 restart <n>: restore program context from a checkpoint.\n\
653 Argument 'n' is checkpoint ID, as displayed by 'info checkpoints'."));
655 /* Delete-checkpoint command: kill the process and remove it from
658 add_com ("delete-checkpoint", class_obscure
, delete_fork_command
, _("\
659 Delete a fork/checkpoint (experimental)."));
661 /* Detach-checkpoint command: release the process to run independantly,
662 and remove it from the fork list. */
664 add_com ("detach-checkpoint", class_obscure
, detach_fork_command
, _("\
665 Detach from a fork/checkpoint (experimental)."));
667 /* Info checkpoints command: list all forks/checkpoints
668 currently under gdb's control. */
670 add_info ("checkpoints", info_forks_command
,
671 _("IDs of currently known forks/checkpoints."));
673 /* Command aliases (let "fork" and "checkpoint" be used
676 add_com_alias ("delete-fork", "delete-checkpoint", class_obscure
, 1);
677 add_com_alias ("detach-fork", "detach-checkpoint", class_obscure
, 1);
678 add_info_alias ("forks", "checkpoints", 0);
680 /* "fork <n>" (by analogy to "thread <n>"). */
681 add_com ("fork", class_obscure
, fork_command
, _("\
682 fork <n>: Switch between forked processes.\n\
683 Argument 'n' is fork ID, as displayed by 'info forks'."));
685 /* "process <proc id>" as opposed to "fork <fork id>". */
686 add_com ("process", class_obscure
, process_command
, _("\
687 process <pid>: Switch between forked processes.\n\
688 Argument 'pid' is process ID, as displayed by 'info forks' or 'shell ps'."));