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, Boston, MA 02111-1307, USA. */
24 #include "frame.h" /* required by inferior.h */
31 #include <sys/types.h>
37 # ifdef HAVE_SYS_WAIT_H
38 # include <sys/wait.h>
42 /* "wait.h" fills in the gaps left by <wait.h> */
48 extern struct symtab_and_line
*
49 child_enable_exception_callback
PARAMS ((enum exception_event_kind
, int));
51 extern struct exception_event_record
*
52 child_get_current_exception_event
PARAMS ((void));
54 extern void _initialize_inftarg
PARAMS ((void));
57 child_prepare_to_store
PARAMS ((void));
60 static int child_wait
PARAMS ((int, struct target_waitstatus
*));
61 #endif /* CHILD_WAIT */
63 #if !defined(CHILD_POST_WAIT)
65 child_post_wait
PARAMS ((int, int));
68 static void child_open
PARAMS ((char *, int));
71 child_files_info
PARAMS ((struct target_ops
*));
74 child_detach
PARAMS ((char *, int));
77 child_detach_from_process
PARAMS ((int, char *, int, int));
80 child_attach
PARAMS ((char *, int));
83 child_attach_to_process
PARAMS ((char *, int, int));
85 #if !defined(CHILD_POST_ATTACH)
86 extern void child_post_attach
PARAMS ((int));
90 child_require_attach
PARAMS ((char *, int));
93 child_require_detach
PARAMS ((int, char *, int));
96 ptrace_me
PARAMS ((void));
99 ptrace_him
PARAMS ((int));
102 child_create_inferior
PARAMS ((char *, char *, char **));
105 child_mourn_inferior
PARAMS ((void));
108 child_can_run
PARAMS ((void));
111 child_stop
PARAMS ((void));
113 #ifndef CHILD_THREAD_ALIVE
114 int child_thread_alive
PARAMS ((int));
117 static void init_child_ops
PARAMS ((void));
119 extern char **environ
;
121 struct target_ops child_ops
;
123 int child_suppress_run
= 0; /* Non-zero if inftarg should pretend not to
124 be a runnable target. Used by targets
125 that can sit atop inftarg, such as HPUX
131 /* Enable HACK for ttrace work. In
132 * infttrace.c/require_notification_of_events,
133 * this is set to 0 so that the loop in child_wait
136 int not_same_real_pid
= 1;
140 /* Wait for child to do something. Return pid of child, or -1 in case
141 of error; store status through argument pointer OURSTATUS. */
144 child_wait (pid
, ourstatus
)
146 struct target_waitstatus
*ourstatus
;
150 char *execd_pathname
= NULL
;
154 enum target_waitkind kind
;
157 set_sigint_trap(); /* Causes SIGINT to be passed on to the
161 pid
= ptrace_wait (inferior_pid
, &status
);
171 if (save_errno
== EINTR
)
174 fprintf_unfiltered (gdb_stderr
, "Child process unexpectedly missing: %s.\n",
175 safe_strerror (save_errno
));
177 /* Claim it exited with unknown signal. */
178 ourstatus
->kind
= TARGET_WAITKIND_SIGNALLED
;
179 ourstatus
->value
.sig
= TARGET_SIGNAL_UNKNOWN
;
185 if (target_has_exited (pid
, status
, &exit_status
))
187 /* ??rehrauer: For now, ignore this. */
191 if (!target_thread_alive (pid
))
193 ourstatus
->kind
= TARGET_WAITKIND_SPURIOUS
;
197 if (target_has_forked (pid
, &related_pid
)
198 && ((pid
== inferior_pid
) || (related_pid
== inferior_pid
)))
200 ourstatus
->kind
= TARGET_WAITKIND_FORKED
;
201 ourstatus
->value
.related_pid
= related_pid
;
205 if (target_has_vforked (pid
, &related_pid
)
206 && ((pid
== inferior_pid
) || (related_pid
== inferior_pid
)))
208 ourstatus
->kind
= TARGET_WAITKIND_VFORKED
;
209 ourstatus
->value
.related_pid
= related_pid
;
213 if (target_has_execd (pid
, &execd_pathname
))
215 /* Are we ignoring initial exec events? (This is likely because
216 we're in the process of starting up the inferior, and another
217 (older) mechanism handles those.) If so, we'll report this
218 as a regular stop, not an exec.
220 if (inferior_ignoring_startup_exec_events
)
222 inferior_ignoring_startup_exec_events
--;
226 ourstatus
->kind
= TARGET_WAITKIND_EXECD
;
227 ourstatus
->value
.execd_pathname
= execd_pathname
;
232 /* All we must do with these is communicate their occurrence
233 to wait_for_inferior...
235 if (target_has_syscall_event (pid
, &kind
, &syscall_id
))
237 ourstatus
->kind
= kind
;
238 ourstatus
->value
.syscall_id
= syscall_id
;
242 /*## } while (pid != inferior_pid); ##*/ /* Some other child died or stopped */
243 /* 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
)
517 char *path
= getenv ("PATH");
521 /* On HP-UX, we have a possible bad interaction between
522 * the start-up-with-shell code and our catch-fork/catch-exec
523 * logic. To avoid the bad interaction, we start up with the
524 * C shell ("csh") and pass it the "-f" flag (fast start-up,
525 * don't run .cshrc code).
526 * See further comments in inferior.h toward the bottom
527 * (STARTUP_WITH_SHELL flag) and in fork-child.c
530 /* Rather than passing in a hard-wired path like "/bin/csh",
531 * we look down the PATH to find csh. I took this code from
532 * procfs.c, which is the file in the Sun-specific part of GDB
533 * analogous to inftarg.c. See procfs.c for more detailed
538 path
= "/bin:/usr/bin";
539 tryname
= alloca (strlen (path
) + strlen (shell_file
) + 2);
540 for (p
= path
; p
!= NULL
; p
= p1
? p1
+ 1: NULL
)
542 p1
= strchr (p
, ':');
547 strncpy (tryname
, p
, len
);
549 strcat (tryname
, "/");
550 strcat (tryname
, shell_file
);
551 if (access (tryname
, X_OK
) < 0)
553 if (stat (tryname
, &statbuf
) < 0)
555 if (!S_ISREG (statbuf
.st_mode
))
556 /* We certainly need to reject directories. I'm not quite
557 as sure about FIFOs, sockets, etc., but I kind of doubt
558 that people want to exec() these things. */
563 /* Not found. I replaced the error() which existed in procfs.c
564 * with simply passing in NULL and hoping fork_inferior()
565 * can deal with it. - RT
567 /* error ("Can't find shell %s in PATH", shell_file); */
570 shell_file
= tryname
;
572 fork_inferior (exec_file
, allargs
, env
, ptrace_me
, ptrace_him
, pre_fork_inferior
, NULL
);
574 fork_inferior (exec_file
, allargs
, env
, ptrace_me
, ptrace_him
, NULL
, NULL
);
576 /* We are at the first instruction we care about. */
577 /* Pedal to the metal... */
578 proceed ((CORE_ADDR
) -1, TARGET_SIGNAL_0
, 0);
581 #if !defined(CHILD_POST_STARTUP_INFERIOR)
583 child_post_startup_inferior (pid
)
586 /* This version of Unix doesn't require a meaningful "post startup inferior"
587 operation by a debugger.
592 #if !defined(CHILD_ACKNOWLEDGE_CREATED_INFERIOR)
594 child_acknowledge_created_inferior (pid
)
597 /* This version of Unix doesn't require a meaningful "acknowledge created inferior"
598 operation by a debugger.
605 child_clone_and_follow_inferior (child_pid
, followed_child
)
609 clone_and_follow_inferior (child_pid
, followed_child
);
611 /* Don't resume CHILD_PID; it's stopped where it ought to be, until
612 the decision gets made elsewhere how to continue it.
617 #if !defined(CHILD_POST_FOLLOW_INFERIOR_BY_CLONE)
619 child_post_follow_inferior_by_clone ()
621 /* This version of Unix doesn't require a meaningful "post follow inferior"
622 operation by a clone debugger.
627 #if !defined(CHILD_INSERT_FORK_CATCHPOINT)
629 child_insert_fork_catchpoint (pid
)
632 /* This version of Unix doesn't support notification of fork events. */
637 #if !defined(CHILD_REMOVE_FORK_CATCHPOINT)
639 child_remove_fork_catchpoint (pid
)
642 /* This version of Unix doesn't support notification of fork events. */
647 #if !defined(CHILD_INSERT_VFORK_CATCHPOINT)
649 child_insert_vfork_catchpoint (pid
)
652 /* This version of Unix doesn't support notification of vfork events. */
657 #if !defined(CHILD_REMOVE_VFORK_CATCHPOINT)
659 child_remove_vfork_catchpoint (pid
)
662 /* This version of Unix doesn't support notification of vfork events. */
667 #if !defined(CHILD_HAS_FORKED)
669 child_has_forked (pid
, child_pid
)
673 /* This version of Unix doesn't support notification of fork events. */
679 #if !defined(CHILD_HAS_VFORKED)
681 child_has_vforked (pid
, child_pid
)
685 /* This version of Unix doesn't support notification of vfork events.
692 #if !defined(CHILD_CAN_FOLLOW_VFORK_PRIOR_TO_EXEC)
694 child_can_follow_vfork_prior_to_exec ()
696 /* This version of Unix doesn't support notification of vfork events.
697 However, if it did, it probably wouldn't allow vforks to be followed
698 before the following exec.
705 #if !defined(CHILD_POST_FOLLOW_VFORK)
707 child_post_follow_vfork (parent_pid
, followed_parent
, child_pid
, followed_child
)
713 /* This version of Unix doesn't require a meaningful "post follow vfork"
714 operation by a clone debugger.
719 #if !defined(CHILD_INSERT_EXEC_CATCHPOINT)
721 child_insert_exec_catchpoint (pid
)
724 /* This version of Unix doesn't support notification of exec events. */
729 #if !defined(CHILD_REMOVE_EXEC_CATCHPOINT)
731 child_remove_exec_catchpoint (pid
)
734 /* This version of Unix doesn't support notification of exec events. */
739 #if !defined(CHILD_HAS_EXECD)
741 child_has_execd (pid
, execd_pathname
)
743 char ** execd_pathname
;
745 /* This version of Unix doesn't support notification of exec events.
752 #if !defined(CHILD_REPORTED_EXEC_EVENTS_PER_EXEC_CALL)
754 child_reported_exec_events_per_exec_call ()
756 /* This version of Unix doesn't support notification of exec events.
763 #if !defined(CHILD_HAS_SYSCALL_EVENT)
765 child_has_syscall_event (pid
, kind
, syscall_id
)
767 enum target_waitkind
* kind
;
770 /* This version of Unix doesn't support notification of syscall events.
777 #if !defined(CHILD_HAS_EXITED)
779 child_has_exited (pid
, wait_status
, exit_status
)
784 if (WIFEXITED (wait_status
))
786 *exit_status
= WEXITSTATUS (wait_status
);
790 if (WIFSIGNALED (wait_status
))
792 *exit_status
= 0; /* ?? Don't know what else to say here. */
796 /* ?? Do we really need to consult the event state, too? Assume the
797 wait_state alone suffices.
805 child_mourn_inferior ()
807 unpush_target (&child_ops
);
808 generic_mourn_inferior ();
814 /* This variable is controlled by modules that sit atop inftarg that may layer
815 their own process structure atop that provided here. hpux-thread.c does
816 this because of the Hpux user-mode level thread model. */
818 return !child_suppress_run
;
821 /* Send a SIGINT to the process group. This acts just like the user typed a
822 ^C on the controlling terminal.
824 XXX - This may not be correct for all systems. Some may want to use
825 killpg() instead of kill (-pgrp). */
830 extern pid_t inferior_process_group
;
832 kill (-inferior_process_group
, SIGINT
);
835 #if !defined(CHILD_ENABLE_EXCEPTION_CALLBACK)
836 struct symtab_and_line
*
837 child_enable_exception_callback (kind
, enable
)
838 enum exception_event_kind kind
;
841 return (struct symtab_and_line
*) NULL
;
845 #if !defined(CHILD_GET_CURRENT_EXCEPTION_EVENT)
846 struct exception_event_record
*
847 child_get_current_exception_event ()
849 return (struct exception_event_record
*) NULL
;
854 #if !defined(CHILD_PID_TO_EXEC_FILE)
856 child_pid_to_exec_file (pid
)
859 /* This version of Unix doesn't support translation of a process ID
860 to the filename of the executable file.
867 child_core_file_to_sym_file (core
)
870 /* The target stratum for a running executable need not support
881 child_ops
.to_shortname
= "child";
882 child_ops
.to_longname
= "Unix child process";
883 child_ops
.to_doc
= "Unix child process (started by the \"run\" command).";
884 child_ops
.to_open
= child_open
;
885 child_ops
.to_attach
= child_attach
;
886 child_ops
.to_post_attach
= child_post_attach
;
887 child_ops
.to_require_attach
= child_require_attach
;
888 child_ops
.to_detach
= child_detach
;
889 child_ops
.to_require_detach
= child_require_detach
;
890 child_ops
.to_resume
= child_resume
;
891 child_ops
.to_wait
= child_wait
;
892 child_ops
.to_post_wait
= child_post_wait
;
893 child_ops
.to_fetch_registers
= fetch_inferior_registers
;
894 child_ops
.to_store_registers
= store_inferior_registers
;
895 child_ops
.to_prepare_to_store
= child_prepare_to_store
;
896 child_ops
.to_xfer_memory
= child_xfer_memory
;
897 child_ops
.to_files_info
= child_files_info
;
898 child_ops
.to_insert_breakpoint
= memory_insert_breakpoint
;
899 child_ops
.to_remove_breakpoint
= memory_remove_breakpoint
;
900 child_ops
.to_terminal_init
= terminal_init_inferior
;
901 child_ops
.to_terminal_inferior
= terminal_inferior
;
902 child_ops
.to_terminal_ours_for_output
= terminal_ours_for_output
;
903 child_ops
.to_terminal_ours
= terminal_ours
;
904 child_ops
.to_terminal_info
= child_terminal_info
;
905 child_ops
.to_kill
= kill_inferior
;
906 child_ops
.to_create_inferior
= child_create_inferior
;
907 child_ops
.to_post_startup_inferior
= child_post_startup_inferior
;
908 child_ops
.to_acknowledge_created_inferior
= child_acknowledge_created_inferior
;
909 child_ops
.to_clone_and_follow_inferior
= child_clone_and_follow_inferior
;
910 child_ops
.to_post_follow_inferior_by_clone
= child_post_follow_inferior_by_clone
;
911 child_ops
.to_insert_fork_catchpoint
= child_insert_fork_catchpoint
;
912 child_ops
.to_remove_fork_catchpoint
= child_remove_fork_catchpoint
;
913 child_ops
.to_insert_vfork_catchpoint
= child_insert_vfork_catchpoint
;
914 child_ops
.to_remove_vfork_catchpoint
= child_remove_vfork_catchpoint
;
915 child_ops
.to_has_forked
= child_has_forked
;
916 child_ops
.to_has_vforked
= child_has_vforked
;
917 child_ops
.to_can_follow_vfork_prior_to_exec
= child_can_follow_vfork_prior_to_exec
;
918 child_ops
.to_post_follow_vfork
= child_post_follow_vfork
;
919 child_ops
.to_insert_exec_catchpoint
= child_insert_exec_catchpoint
;
920 child_ops
.to_remove_exec_catchpoint
= child_remove_exec_catchpoint
;
921 child_ops
.to_has_execd
= child_has_execd
;
922 child_ops
.to_reported_exec_events_per_exec_call
= child_reported_exec_events_per_exec_call
;
923 child_ops
.to_has_syscall_event
= child_has_syscall_event
;
924 child_ops
.to_has_exited
= child_has_exited
;
925 child_ops
.to_mourn_inferior
= child_mourn_inferior
;
926 child_ops
.to_can_run
= child_can_run
;
927 child_ops
.to_thread_alive
= child_thread_alive
;
928 child_ops
.to_stop
= child_stop
;
929 child_ops
.to_enable_exception_callback
= child_enable_exception_callback
;
930 child_ops
.to_get_current_exception_event
= child_get_current_exception_event
;
931 child_ops
.to_pid_to_exec_file
= child_pid_to_exec_file
;
932 child_ops
.to_core_file_to_sym_file
= child_core_file_to_sym_file
;
933 child_ops
.to_stratum
= process_stratum
;
934 child_ops
.to_has_all_memory
= 1;
935 child_ops
.to_has_memory
= 1;
936 child_ops
.to_has_stack
= 1;
937 child_ops
.to_has_registers
= 1;
938 child_ops
.to_has_execution
= 1;
939 child_ops
.to_magic
= OPS_MAGIC
;
943 _initialize_inftarg ()
945 #ifdef HAVE_OPTIONAL_PROC_FS
949 /* If we have an optional /proc filesystem (e.g. under OSF/1),
950 don't add ptrace support if we can access the running GDB via /proc. */
951 #ifndef PROC_NAME_FMT
952 #define PROC_NAME_FMT "/proc/%05d"
954 sprintf (procname
, PROC_NAME_FMT
, getpid ());
955 if ((fd
= open (procname
, O_RDONLY
)) >= 0)
963 add_target (&child_ops
);