1 /* Target-vector operations for controlling Unix child processes, for GDB.
2 Copyright 1990-1996, 1998, 1999 Free Software Foundation, Inc.
3 Contributed by Cygnus Support.
5 ## Contains temporary hacks..
7 This file is part of GDB.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 2 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 59 Temple Place - Suite 330,
22 Boston, MA 02111-1307, USA. */
25 #include "frame.h" /* required by inferior.h */
32 #include <sys/types.h>
38 #ifdef HAVE_SYS_WAIT_H
43 /* "wait.h" fills in the gaps left by <wait.h> */
46 extern struct symtab_and_line *
47 child_enable_exception_callback PARAMS ((enum exception_event_kind, int));
49 extern struct exception_event_record *
50 child_get_current_exception_event PARAMS ((void));
52 extern void _initialize_inftarg PARAMS ((void));
55 child_prepare_to_store PARAMS ((void));
58 static int child_wait PARAMS ((int, struct target_waitstatus *));
59 #endif /* CHILD_WAIT */
61 #if !defined(CHILD_POST_WAIT)
63 child_post_wait PARAMS ((int, int));
66 static void child_open PARAMS ((char *, int));
69 child_files_info PARAMS ((struct target_ops *));
72 child_detach PARAMS ((char *, int));
75 child_detach_from_process PARAMS ((int, char *, int, int));
78 child_attach PARAMS ((char *, int));
81 child_attach_to_process PARAMS ((char *, int, int));
83 #if !defined(CHILD_POST_ATTACH)
84 extern void child_post_attach PARAMS ((int));
88 child_require_attach PARAMS ((char *, int));
91 child_require_detach PARAMS ((int, char *, int));
94 ptrace_me PARAMS ((void));
97 ptrace_him PARAMS ((int));
100 child_create_inferior PARAMS ((char *, char *, char **));
103 child_mourn_inferior PARAMS ((void));
106 child_can_run PARAMS ((void));
109 child_stop PARAMS ((void));
111 #ifndef CHILD_THREAD_ALIVE
112 int child_thread_alive PARAMS ((int));
115 static void init_child_ops PARAMS ((void));
117 extern char **environ;
119 struct target_ops child_ops;
121 int child_suppress_run = 0; /* Non-zero if inftarg should pretend not to
122 be a runnable target. Used by targets
123 that can sit atop inftarg, such as HPUX
129 /* Enable HACK for ttrace work. In
130 * infttrace.c/require_notification_of_events,
131 * this is set to 0 so that the loop in child_wait
134 int not_same_real_pid = 1;
138 /* Wait for child to do something. Return pid of child, or -1 in case
139 of error; store status through argument pointer OURSTATUS. */
142 child_wait (pid, ourstatus)
144 struct target_waitstatus *ourstatus;
148 char *execd_pathname = NULL;
152 enum target_waitkind kind;
156 set_sigint_trap (); /* Causes SIGINT to be passed on to the
160 pid = ptrace_wait (inferior_pid, &status);
166 clear_sigint_trap ();
170 if (save_errno == EINTR)
173 fprintf_unfiltered (gdb_stderr, "Child process unexpectedly missing: %s.\n",
174 safe_strerror (save_errno));
176 /* Claim it exited with unknown signal. */
177 ourstatus->kind = TARGET_WAITKIND_SIGNALLED;
178 ourstatus->value.sig = TARGET_SIGNAL_UNKNOWN;
184 if (target_has_exited (pid, status, &exit_status))
186 /* ??rehrauer: For now, ignore this. */
190 if (!target_thread_alive (pid))
192 ourstatus->kind = TARGET_WAITKIND_SPURIOUS;
196 if (target_has_forked (pid, &related_pid)
197 && ((pid == inferior_pid) || (related_pid == inferior_pid)))
199 ourstatus->kind = TARGET_WAITKIND_FORKED;
200 ourstatus->value.related_pid = related_pid;
204 if (target_has_vforked (pid, &related_pid)
205 && ((pid == inferior_pid) || (related_pid == inferior_pid)))
207 ourstatus->kind = TARGET_WAITKIND_VFORKED;
208 ourstatus->value.related_pid = related_pid;
212 if (target_has_execd (pid, &execd_pathname))
214 /* Are we ignoring initial exec events? (This is likely because
215 we're in the process of starting up the inferior, and another
216 (older) mechanism handles those.) If so, we'll report this
217 as a regular stop, not an exec.
219 if (inferior_ignoring_startup_exec_events)
221 inferior_ignoring_startup_exec_events--;
225 ourstatus->kind = TARGET_WAITKIND_EXECD;
226 ourstatus->value.execd_pathname = execd_pathname;
231 /* All we must do with these is communicate their occurrence
232 to wait_for_inferior...
234 if (target_has_syscall_event (pid, &kind, &syscall_id))
236 ourstatus->kind = kind;
237 ourstatus->value.syscall_id = syscall_id;
241 /*## } while (pid != inferior_pid); ## *//* Some other child died or stopped */
242 /* hack for thread testing */
244 while ((pid != inferior_pid) && not_same_real_pid);
247 store_waitstatus (ourstatus, status);
250 #endif /* CHILD_WAIT */
252 #if !defined(CHILD_POST_WAIT)
254 child_post_wait (pid, wait_status)
258 /* This version of Unix doesn't require a meaningful "post wait"
265 #ifndef CHILD_THREAD_ALIVE
267 /* Check to see if the given thread is alive.
269 FIXME: Is kill() ever the right way to do this? I doubt it, but
270 for now we're going to try and be compatable with the old thread
273 child_thread_alive (pid)
276 return (kill (pid, 0) != -1);
282 child_attach_to_process (args, from_tty, after_fork)
288 error_no_arg ("process-id to attach");
290 #ifndef ATTACH_DETACH
291 error ("Can't attach to a process on this machine.");
299 pid = strtol (args, &dummy, 0);
300 /* Some targets don't set errno on errors, grrr! */
301 if ((pid == 0) && (args == dummy))
302 error ("Illegal process-id: %s\n", args);
304 if (pid == getpid ()) /* Trying to masturbate? */
305 error ("I refuse to debug myself!");
309 exec_file = (char *) get_exec_file (0);
312 printf_unfiltered ("Attaching after fork to %s\n",
313 target_pid_to_str (pid));
315 printf_unfiltered ("Attaching to program: %s, %s\n", exec_file,
316 target_pid_to_str (pid));
318 printf_unfiltered ("Attaching to %s\n", target_pid_to_str (pid));
320 gdb_flush (gdb_stdout);
326 REQUIRE_ATTACH (pid);
329 push_target (&child_ops);
331 #endif /* ATTACH_DETACH */
335 /* Attach to process PID, then initialize for debugging it. */
338 child_attach (args, from_tty)
342 child_attach_to_process (args, from_tty, 0);
345 #if !defined(CHILD_POST_ATTACH)
347 child_post_attach (pid)
350 /* This version of Unix doesn't require a meaningful "post attach"
351 operation by a debugger. */
356 child_require_attach (args, from_tty)
360 child_attach_to_process (args, from_tty, 1);
364 child_detach_from_process (pid, args, from_tty, after_fork)
376 char *exec_file = get_exec_file (0);
380 printf_unfiltered ("Detaching after fork from %s\n",
381 target_pid_to_str (pid));
383 printf_unfiltered ("Detaching from program: %s, %s\n", exec_file,
384 target_pid_to_str (pid));
385 gdb_flush (gdb_stdout);
388 siggnal = atoi (args);
393 REQUIRE_DETACH (pid, siggnal);
396 error ("This version of Unix does not support detaching a process.");
400 /* Take a program previously attached to and detaches it.
401 The program resumes execution and will no longer stop
402 on signals, etc. We'd better not have left any breakpoints
403 in the program or it'll die when it hits one. For this
404 to work, it may be necessary for the process to have been
405 previously attached. It *might* work if the program was
406 started via the normal ptrace (PTRACE_TRACEME). */
409 child_detach (args, from_tty)
413 child_detach_from_process (inferior_pid, args, from_tty, 0);
415 unpush_target (&child_ops);
419 child_require_detach (pid, args, from_tty)
424 child_detach_from_process (pid, args, from_tty, 1);
428 /* Get ready to modify the registers array. On machines which store
429 individual registers, this doesn't need to do anything. On machines
430 which store all the registers in one fell swoop, this makes sure
431 that registers contains all the registers from the program being
435 child_prepare_to_store ()
437 #ifdef CHILD_PREPARE_TO_STORE
438 CHILD_PREPARE_TO_STORE ();
442 /* Print status information about what we're accessing. */
445 child_files_info (ignore)
446 struct target_ops *ignore;
448 printf_unfiltered ("\tUsing the running image of %s %s.\n",
449 attach_flag ? "attached" : "child", target_pid_to_str (inferior_pid));
454 child_open (arg, from_tty)
458 error ("Use the \"run\" command to start a Unix child process.");
461 /* Stub function which causes the inferior that runs it, to be ptrace-able
462 by its parent process. */
467 /* "Trace me, Dr. Memory!" */
468 call_ptrace (0, 0, (PTRACE_ARG3_TYPE) 0, 0);
471 /* Stub function which causes the GDB that runs it, to start ptrace-ing
472 the child process. */
478 push_target (&child_ops);
480 /* On some targets, there must be some explicit synchronization
481 between the parent and child processes after the debugger
482 forks, and before the child execs the debuggee program. This
483 call basically gives permission for the child to exec.
486 target_acknowledge_created_inferior (pid);
488 /* START_INFERIOR_TRAPS_EXPECTED is defined in inferior.h,
489 * and will be 1 or 2 depending on whether we're starting
490 * without or with a shell.
492 startup_inferior (START_INFERIOR_TRAPS_EXPECTED);
494 /* On some targets, there must be some explicit actions taken after
495 the inferior has been started up.
497 target_post_startup_inferior (pid);
500 /* Start an inferior Unix child process and sets inferior_pid to its pid.
501 EXEC_FILE is the file to run.
502 ALLARGS is a string containing the arguments to the program.
503 ENV is the environment vector to pass. Errors reported with error(). */
506 child_create_inferior (exec_file, allargs, env)
512 fork_inferior (exec_file, allargs, env, ptrace_me, ptrace_him, pre_fork_inferior, NULL);
514 fork_inferior (exec_file, allargs, env, ptrace_me, ptrace_him, NULL, NULL);
516 /* We are at the first instruction we care about. */
517 /* Pedal to the metal... */
518 proceed ((CORE_ADDR) - 1, TARGET_SIGNAL_0, 0);
521 #if !defined(CHILD_POST_STARTUP_INFERIOR)
523 child_post_startup_inferior (pid)
526 /* This version of Unix doesn't require a meaningful "post startup inferior"
527 operation by a debugger.
532 #if !defined(CHILD_ACKNOWLEDGE_CREATED_INFERIOR)
534 child_acknowledge_created_inferior (pid)
537 /* This version of Unix doesn't require a meaningful "acknowledge created inferior"
538 operation by a debugger.
545 child_clone_and_follow_inferior (child_pid, followed_child)
549 clone_and_follow_inferior (child_pid, followed_child);
551 /* Don't resume CHILD_PID; it's stopped where it ought to be, until
552 the decision gets made elsewhere how to continue it.
557 #if !defined(CHILD_POST_FOLLOW_INFERIOR_BY_CLONE)
559 child_post_follow_inferior_by_clone ()
561 /* This version of Unix doesn't require a meaningful "post follow inferior"
562 operation by a clone debugger.
567 #if !defined(CHILD_INSERT_FORK_CATCHPOINT)
569 child_insert_fork_catchpoint (pid)
572 /* This version of Unix doesn't support notification of fork events. */
577 #if !defined(CHILD_REMOVE_FORK_CATCHPOINT)
579 child_remove_fork_catchpoint (pid)
582 /* This version of Unix doesn't support notification of fork events. */
587 #if !defined(CHILD_INSERT_VFORK_CATCHPOINT)
589 child_insert_vfork_catchpoint (pid)
592 /* This version of Unix doesn't support notification of vfork events. */
597 #if !defined(CHILD_REMOVE_VFORK_CATCHPOINT)
599 child_remove_vfork_catchpoint (pid)
602 /* This version of Unix doesn't support notification of vfork events. */
607 #if !defined(CHILD_HAS_FORKED)
609 child_has_forked (pid, child_pid)
613 /* This version of Unix doesn't support notification of fork events. */
619 #if !defined(CHILD_HAS_VFORKED)
621 child_has_vforked (pid, child_pid)
625 /* This version of Unix doesn't support notification of vfork events.
632 #if !defined(CHILD_CAN_FOLLOW_VFORK_PRIOR_TO_EXEC)
634 child_can_follow_vfork_prior_to_exec ()
636 /* This version of Unix doesn't support notification of vfork events.
637 However, if it did, it probably wouldn't allow vforks to be followed
638 before the following exec.
645 #if !defined(CHILD_POST_FOLLOW_VFORK)
647 child_post_follow_vfork (parent_pid, followed_parent, child_pid, followed_child)
653 /* This version of Unix doesn't require a meaningful "post follow vfork"
654 operation by a clone debugger.
659 #if !defined(CHILD_INSERT_EXEC_CATCHPOINT)
661 child_insert_exec_catchpoint (pid)
664 /* This version of Unix doesn't support notification of exec events. */
669 #if !defined(CHILD_REMOVE_EXEC_CATCHPOINT)
671 child_remove_exec_catchpoint (pid)
674 /* This version of Unix doesn't support notification of exec events. */
679 #if !defined(CHILD_HAS_EXECD)
681 child_has_execd (pid, execd_pathname)
683 char **execd_pathname;
685 /* This version of Unix doesn't support notification of exec events.
692 #if !defined(CHILD_REPORTED_EXEC_EVENTS_PER_EXEC_CALL)
694 child_reported_exec_events_per_exec_call ()
696 /* This version of Unix doesn't support notification of exec events.
703 #if !defined(CHILD_HAS_SYSCALL_EVENT)
705 child_has_syscall_event (pid, kind, syscall_id)
707 enum target_waitkind *kind;
710 /* This version of Unix doesn't support notification of syscall events.
717 #if !defined(CHILD_HAS_EXITED)
719 child_has_exited (pid, wait_status, exit_status)
724 if (WIFEXITED (wait_status))
726 *exit_status = WEXITSTATUS (wait_status);
730 if (WIFSIGNALED (wait_status))
732 *exit_status = 0; /* ?? Don't know what else to say here. */
736 /* ?? Do we really need to consult the event state, too? Assume the
737 wait_state alone suffices.
745 child_mourn_inferior ()
747 unpush_target (&child_ops);
748 generic_mourn_inferior ();
754 /* This variable is controlled by modules that sit atop inftarg that may layer
755 their own process structure atop that provided here. hpux-thread.c does
756 this because of the Hpux user-mode level thread model. */
758 return !child_suppress_run;
761 /* Send a SIGINT to the process group. This acts just like the user typed a
762 ^C on the controlling terminal.
764 XXX - This may not be correct for all systems. Some may want to use
765 killpg() instead of kill (-pgrp). */
770 extern pid_t inferior_process_group;
772 kill (-inferior_process_group, SIGINT);
775 #if !defined(CHILD_ENABLE_EXCEPTION_CALLBACK)
776 struct symtab_and_line *
777 child_enable_exception_callback (kind, enable)
778 enum exception_event_kind kind;
781 return (struct symtab_and_line *) NULL;
785 #if !defined(CHILD_GET_CURRENT_EXCEPTION_EVENT)
786 struct exception_event_record *
787 child_get_current_exception_event ()
789 return (struct exception_event_record *) NULL;
794 #if !defined(CHILD_PID_TO_EXEC_FILE)
796 child_pid_to_exec_file (pid)
799 /* This version of Unix doesn't support translation of a process ID
800 to the filename of the executable file.
807 child_core_file_to_sym_file (core)
810 /* The target stratum for a running executable need not support
821 child_ops.to_shortname = "child";
822 child_ops.to_longname = "Unix child process";
823 child_ops.to_doc = "Unix child process (started by the \"run\" command).";
824 child_ops.to_open = child_open;
825 child_ops.to_attach = child_attach;
826 child_ops.to_post_attach = child_post_attach;
827 child_ops.to_require_attach = child_require_attach;
828 child_ops.to_detach = child_detach;
829 child_ops.to_require_detach = child_require_detach;
830 child_ops.to_resume = child_resume;
831 child_ops.to_wait = child_wait;
832 child_ops.to_post_wait = child_post_wait;
833 child_ops.to_fetch_registers = fetch_inferior_registers;
834 child_ops.to_store_registers = store_inferior_registers;
835 child_ops.to_prepare_to_store = child_prepare_to_store;
836 child_ops.to_xfer_memory = child_xfer_memory;
837 child_ops.to_files_info = child_files_info;
838 child_ops.to_insert_breakpoint = memory_insert_breakpoint;
839 child_ops.to_remove_breakpoint = memory_remove_breakpoint;
840 child_ops.to_terminal_init = terminal_init_inferior;
841 child_ops.to_terminal_inferior = terminal_inferior;
842 child_ops.to_terminal_ours_for_output = terminal_ours_for_output;
843 child_ops.to_terminal_ours = terminal_ours;
844 child_ops.to_terminal_info = child_terminal_info;
845 child_ops.to_kill = kill_inferior;
846 child_ops.to_create_inferior = child_create_inferior;
847 child_ops.to_post_startup_inferior = child_post_startup_inferior;
848 child_ops.to_acknowledge_created_inferior = child_acknowledge_created_inferior;
849 child_ops.to_clone_and_follow_inferior = child_clone_and_follow_inferior;
850 child_ops.to_post_follow_inferior_by_clone = child_post_follow_inferior_by_clone;
851 child_ops.to_insert_fork_catchpoint = child_insert_fork_catchpoint;
852 child_ops.to_remove_fork_catchpoint = child_remove_fork_catchpoint;
853 child_ops.to_insert_vfork_catchpoint = child_insert_vfork_catchpoint;
854 child_ops.to_remove_vfork_catchpoint = child_remove_vfork_catchpoint;
855 child_ops.to_has_forked = child_has_forked;
856 child_ops.to_has_vforked = child_has_vforked;
857 child_ops.to_can_follow_vfork_prior_to_exec = child_can_follow_vfork_prior_to_exec;
858 child_ops.to_post_follow_vfork = child_post_follow_vfork;
859 child_ops.to_insert_exec_catchpoint = child_insert_exec_catchpoint;
860 child_ops.to_remove_exec_catchpoint = child_remove_exec_catchpoint;
861 child_ops.to_has_execd = child_has_execd;
862 child_ops.to_reported_exec_events_per_exec_call = child_reported_exec_events_per_exec_call;
863 child_ops.to_has_syscall_event = child_has_syscall_event;
864 child_ops.to_has_exited = child_has_exited;
865 child_ops.to_mourn_inferior = child_mourn_inferior;
866 child_ops.to_can_run = child_can_run;
867 child_ops.to_thread_alive = child_thread_alive;
868 child_ops.to_stop = child_stop;
869 child_ops.to_enable_exception_callback = child_enable_exception_callback;
870 child_ops.to_get_current_exception_event = child_get_current_exception_event;
871 child_ops.to_pid_to_exec_file = child_pid_to_exec_file;
872 child_ops.to_core_file_to_sym_file = child_core_file_to_sym_file;
873 child_ops.to_stratum = process_stratum;
874 child_ops.to_has_all_memory = 1;
875 child_ops.to_has_memory = 1;
876 child_ops.to_has_stack = 1;
877 child_ops.to_has_registers = 1;
878 child_ops.to_has_execution = 1;
879 child_ops.to_magic = OPS_MAGIC;
883 _initialize_inftarg ()
885 #ifdef HAVE_OPTIONAL_PROC_FS
889 /* If we have an optional /proc filesystem (e.g. under OSF/1),
890 don't add ptrace support if we can access the running GDB via /proc. */
891 #ifndef PROC_NAME_FMT
892 #define PROC_NAME_FMT "/proc/%05d"
894 sprintf (procname, PROC_NAME_FMT, getpid ());
895 if ((fd = open (procname, O_RDONLY)) >= 0)
903 add_target (&child_ops);