diff options
author | Mark Kettenis <kettenis@cvs.openbsd.org> | 2005-11-17 15:37:02 +0000 |
---|---|---|
committer | Mark Kettenis <kettenis@cvs.openbsd.org> | 2005-11-17 15:37:02 +0000 |
commit | 663e422563280c82e348cf0228a1e917e0bf0a77 (patch) | |
tree | 29e42827969c00c92d22f43990142440788ed3e5 | |
parent | dcc399b0ce93304893ded8ee582589a061f3bf79 (diff) |
Add support for following forks. Backported from the to-be released gdb 6.4.
Only works on amd64, i386, m88k, mips64, sparc, sparc64 and vax for now.
-rw-r--r-- | gnu/usr.bin/binutils/gdb/inf-ptrace.c | 805 |
1 files changed, 450 insertions, 355 deletions
diff --git a/gnu/usr.bin/binutils/gdb/inf-ptrace.c b/gnu/usr.bin/binutils/gdb/inf-ptrace.c index 74faf5788b6..f2f6d276dd2 100644 --- a/gnu/usr.bin/binutils/gdb/inf-ptrace.c +++ b/gnu/usr.bin/binutils/gdb/inf-ptrace.c @@ -1,7 +1,8 @@ -/* Low level Unix child interface to ptrace, for GDB when running under Unix. +/* Low-level child interface to ptrace. Copyright 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, - 1998, 1999, 2000, 2001, 2002, 2004 Free Software Foundation, Inc. + 1998, 1999, 2000, 2001, 2002, 2004, 2005 + Free Software Foundation, Inc. This file is part of GDB. @@ -21,188 +22,195 @@ Boston, MA 02111-1307, USA. */ #include "defs.h" -#include "observer.h" -#include "gdb_ptrace.h" -#include "inflow.h" -#include "inferior.h" -#include "regcache.h" #include "command.h" +#include "inferior.h" +#include "inflow.h" #include "gdbcore.h" -#include "inf-child.h" -#include "gdbcmd.h" -#include "gdb_string.h" +#include "observer.h" +#include "regcache.h" +#include "gdb_assert.h" +#include "gdb_string.h" +#include "gdb_ptrace.h" #include "gdb_wait.h" #include <signal.h> -/* HACK: Save the ptrace ops returned by ptrace_target. */ +#include "inf-child.h" + +/* HACK: Save the ptrace ops returned by inf_ptrace_target. */ static struct target_ops *ptrace_ops_hack; + -static void -inf_ptrace_kill_inferior (void) +#ifdef PT_GET_PROCESS_STATE + +static int +inf_ptrace_follow_fork (int follow_child) { - int status; - int pid = PIDGET (inferior_ptid); + pid_t pid, fpid; + ptrace_state_t pe; - if (pid == 0) - return; + /* FIXME: kettenis/20050720: This stuff should really be passed as + an argument by our caller. */ + { + ptid_t ptid; + struct target_waitstatus status; - /* This once used to call "kill" to kill the inferior just in case - the inferior was still running. As others have noted in the past - (kingdon) there shouldn't be any way to get here if the inferior - is still running -- else there's a major problem elsewere in gdb - and it needs to be fixed. + get_last_target_status (&ptid, &status); + gdb_assert (status.kind == TARGET_WAITKIND_FORKED); - The kill call causes problems under hpux10, so it's been removed; - if this causes problems we'll deal with them as they arise. */ - ptrace (PT_KILL, pid, (PTRACE_TYPE_ARG3) 0, 0); - wait (&status); - target_mourn_inferior (); -} + pid = ptid_get_pid (ptid); + } -/* Resume execution of the inferior process. If STEP is nonzero, - single-step it. If SIGNAL is nonzero, give it that signal. */ + if (ptrace (PT_GET_PROCESS_STATE, pid, + (PTRACE_TYPE_ARG3)&pe, sizeof pe) == -1) + perror_with_name (("ptrace")); -static void -inf_ptrace_resume (ptid_t ptid, int step, enum target_signal signal) -{ - int request = PT_CONTINUE; - int pid = PIDGET (ptid); + gdb_assert (pe.pe_report_event == PTRACE_FORK); + fpid = pe.pe_other_pid; - if (pid == -1) - /* Resume all threads. */ - /* I think this only gets used in the non-threaded case, where - "resume all threads" and "resume inferior_ptid" are the - same. */ - pid = PIDGET (inferior_ptid); + if (follow_child) + { + inferior_ptid = pid_to_ptid (fpid); + detach_breakpoints (pid); - if (step) + /* Reset breakpoints in the child as appropriate. */ + follow_inferior_reset_breakpoints (); + + if (ptrace (PT_DETACH, pid, (PTRACE_TYPE_ARG3)1, 0) == -1) + perror_with_name (("ptrace")); + } + else { - /* If this system does not support PT_STEP, a higher level - function will have called single_step() to transmute the step - request into a continue request (by setting breakpoints on - all possible successor instructions), so we don't have to - worry about that here. */ - request = PT_STEP; + inferior_ptid = pid_to_ptid (pid); + detach_breakpoints (fpid); + + if (ptrace (PT_DETACH, fpid, (PTRACE_TYPE_ARG3)1, 0) == -1) + perror_with_name (("ptrace")); } - /* An address of (PTRACE_TYPE_ARG3)1 tells ptrace to continue from - where it was. If GDB wanted it to start some other way, we have - already written a new PC value to the child. */ - errno = 0; - ptrace (request, pid, (PTRACE_TYPE_ARG3) 1, target_signal_to_host (signal)); - if (errno != 0) - perror_with_name ("ptrace"); + return 0; } -/* Wait for child to do something. Return pid of child, or -1 in case - of error; store status through argument pointer OURSTATUS. */ +#endif /* PT_GET_PROCESS_STATE */ + -static ptid_t -inf_ptrace_wait (ptid_t ptid, struct target_waitstatus *ourstatus) +/* Prepare to be traced. */ + +static void +inf_ptrace_me (void) { - int save_errno; - int status; - char *execd_pathname = NULL; - int exit_status; - int related_pid; - int syscall_id; - enum target_waitkind kind; - int pid; + /* "Trace me, Dr. Memory!" */ + ptrace (PT_TRACE_ME, 0, (PTRACE_TYPE_ARG3)0, 0); +} - do - { - set_sigint_trap (); /* Causes SIGINT to be passed on to the - attached process. */ - set_sigio_trap (); +/* Start tracing PID. */ - pid = wait (&status); +static void +inf_ptrace_him (int pid) +{ + push_target (ptrace_ops_hack); - save_errno = errno; + /* On some targets, there must be some explicit synchronization + between the parent and child processes after the debugger + forks, and before the child execs the debuggee program. This + call basically gives permission for the child to exec. */ - clear_sigio_trap (); + target_acknowledge_created_inferior (pid); - clear_sigint_trap (); + /* START_INFERIOR_TRAPS_EXPECTED is defined in inferior.h, and will + be 1 or 2 depending on whether we're starting without or with a + shell. */ + startup_inferior (START_INFERIOR_TRAPS_EXPECTED); - if (pid == -1) - { - if (save_errno == EINTR) - continue; + /* On some targets, there must be some explicit actions taken after + the inferior has been started up. */ + target_post_startup_inferior (pid_to_ptid (pid)); +} - fprintf_unfiltered (gdb_stderr, - "Child process unexpectedly missing: %s.\n", - safe_strerror (save_errno)); +/* Start a new inferior Unix child process. EXEC_FILE is the file to + run, ALLARGS is a string containing the arguments to the program. + ENV is the environment vector to pass. If FROM_TTY is non-zero, be + chatty about it. */ - /* Claim it exited with unknown signal. */ - ourstatus->kind = TARGET_WAITKIND_SIGNALLED; - ourstatus->value.sig = TARGET_SIGNAL_UNKNOWN; - return pid_to_ptid (-1); - } +static void +inf_ptrace_create_inferior (char *exec_file, char *allargs, char **env, + int from_tty) +{ + fork_inferior (exec_file, allargs, env, inf_ptrace_me, inf_ptrace_him, + NULL, NULL); - /* Did it exit? - */ - if (target_has_exited (pid, status, &exit_status)) - { - /* ??rehrauer: For now, ignore this. */ - continue; - } + /* We are at the first instruction we care about. */ + observer_notify_inferior_created (¤t_target, from_tty); - if (!target_thread_alive (pid_to_ptid (pid))) - { - ourstatus->kind = TARGET_WAITKIND_SPURIOUS; - return pid_to_ptid (pid); - } - } - while (pid != PIDGET (inferior_ptid)); /* Some other child died or stopped */ + /* Pedal to the metal... */ + proceed ((CORE_ADDR) -1, TARGET_SIGNAL_0, 0); +} - store_waitstatus (ourstatus, status); - return pid_to_ptid (pid); +#ifdef PT_GET_PROCESS_STATE + +static void +inf_ptrace_post_startup_inferior (ptid_t pid) +{ + ptrace_event_t pe; + + /* Set the initial event mask. */ + memset (&pe, 0, sizeof pe); + pe.pe_set_event |= PTRACE_FORK; + if (ptrace (PT_SET_EVENT_MASK, ptid_get_pid (pid), + (PTRACE_TYPE_ARG3)&pe, sizeof pe) == -1) + perror_with_name (("ptrace")); } -/* Check to see if the given thread is alive. +#endif - FIXME: Is kill() ever the right way to do this? I doubt it, but - for now we're going to try and be compatable with the old thread - code. */ +/* Clean up a rotting corpse of an inferior after it died. */ -static int -inf_ptrace_thread_alive (ptid_t ptid) +static void +inf_ptrace_mourn_inferior (void) { - pid_t pid = PIDGET (ptid); + int status; - return (kill (pid, 0) != -1); + /* Wait just one more time to collect the inferior's exit status. + Don not check whether this succeeds though, since we may be + dealing with a process that we attached to. Such a process will + only report its exit status to its origional parent. */ + waitpid (ptid_get_pid (inferior_ptid), &status, 0); + + unpush_target (ptrace_ops_hack); + generic_mourn_inferior (); } -/* Attach to process PID, then initialize for debugging it. */ +/* Attach to the process specified by ARGS. If FROM_TTY is non-zero, + be chatty about it. */ static void inf_ptrace_attach (char *args, int from_tty) { char *exec_file; - int pid; + pid_t pid; char *dummy; if (!args) - error_no_arg ("process-id to attach"); + error_no_arg (_("process-id to attach")); dummy = args; pid = strtol (args, &dummy, 0); - /* Some targets don't set errno on errors, grrr! */ + /* Some targets don't set errno on errors, grrr! */ if (pid == 0 && args == dummy) - error ("Illegal process-id: %s\n", args); + error (_("Illegal process-id: %s."), args); - if (pid == getpid ()) /* Trying to masturbate? */ - error ("I refuse to debug myself!"); + if (pid == getpid ()) /* Trying to masturbate? */ + error (_("I refuse to debug myself!")); if (from_tty) { - exec_file = (char *) get_exec_file (0); + exec_file = get_exec_file (0); if (exec_file) - printf_unfiltered ("Attaching to program: %s, %s\n", exec_file, + printf_unfiltered (_("Attaching to program: %s, %s\n"), exec_file, target_pid_to_str (pid_to_ptid (pid))); else - printf_unfiltered ("Attaching to %s\n", + printf_unfiltered (_("Attaching to %s\n"), target_pid_to_str (pid_to_ptid (pid))); gdb_flush (gdb_stdout); @@ -210,44 +218,54 @@ inf_ptrace_attach (char *args, int from_tty) #ifdef PT_ATTACH errno = 0; - ptrace (PT_ATTACH, pid, (PTRACE_TYPE_ARG3) 0, 0); + ptrace (PT_ATTACH, pid, (PTRACE_TYPE_ARG3)0, 0); if (errno != 0) - perror_with_name ("ptrace"); + perror_with_name (("ptrace")); attach_flag = 1; #else - error ("This system does not support attaching to a process"); + error (_("This system does not support attaching to a process")); #endif inferior_ptid = pid_to_ptid (pid); push_target (ptrace_ops_hack); + + /* Do this first, before anything has had a chance to query the + inferior's symbol table or similar. */ + observer_notify_inferior_created (¤t_target, from_tty); } -static void +#ifdef PT_GET_PROCESS_STATE + +void inf_ptrace_post_attach (int pid) { - /* This version of Unix doesn't require a meaningful "post attach" - operation by a debugger. */ + ptrace_event_t pe; + + /* Set the initial event mask. */ + memset (&pe, 0, sizeof pe); + pe.pe_set_event |= PTRACE_FORK; + if (ptrace (PT_SET_EVENT_MASK, pid, + (PTRACE_TYPE_ARG3)&pe, sizeof pe) == -1) + perror_with_name (("ptrace")); } -/* Take a program previously attached to and detaches it. The program - resumes execution and will no longer stop on signals, etc. We'd - better not have left any breakpoints in the program or it'll die - when it hits one. For this to work, it may be necessary for the - process to have been previously attached. It *might* work if the - program was started via the normal ptrace (PTRACE_TRACEME). */ +#endif + +/* Detach from the inferior, optionally passing it the signal + specified ARGS. If FROM_TTY is non-zero, be chatty about it. */ static void inf_ptrace_detach (char *args, int from_tty) { + pid_t pid = ptid_get_pid (inferior_ptid); int sig = 0; - int pid = PIDGET (inferior_ptid); if (from_tty) { char *exec_file = get_exec_file (0); if (exec_file == 0) exec_file = ""; - printf_unfiltered ("Detaching from program: %s, %s\n", exec_file, + printf_unfiltered (_("Detaching from program: %s, %s\n"), exec_file, target_pid_to_str (pid_to_ptid (pid))); gdb_flush (gdb_stdout); } @@ -255,228 +273,184 @@ inf_ptrace_detach (char *args, int from_tty) sig = atoi (args); #ifdef PT_DETACH + /* We'd better not have left any breakpoints in the program or it'll + die when it hits one. Alsno note that this may only work if we + previously attached to the inferior. It *might* work if we + started the process ourselves. */ errno = 0; - ptrace (PT_DETACH, pid, (PTRACE_TYPE_ARG3) 1, sig); + ptrace (PT_DETACH, pid, (PTRACE_TYPE_ARG3)1, sig); if (errno != 0) - perror_with_name ("ptrace"); + perror_with_name (("ptrace")); attach_flag = 0; #else - error ("This system does not support detaching from a process"); + error (_("This system does not support detaching from a process")); #endif inferior_ptid = null_ptid; unpush_target (ptrace_ops_hack); } -/* Get ready to modify the registers array. On machines which store - individual registers, this doesn't need to do anything. On - machines which store all the registers in one fell swoop, this - makes sure that registers contains all the registers from the - program being debugged. */ - -static void -inf_ptrace_prepare_to_store (void) -{ -} - -/* Print status information about what we're accessing. */ +/* Kill the inferior. */ static void -inf_ptrace_files_info (struct target_ops *ignore) +inf_ptrace_kill (void) { - printf_unfiltered ("\tUsing the running image of %s %s.\n", - attach_flag ? "attached" : "child", - target_pid_to_str (inferior_ptid)); -} + pid_t pid = ptid_get_pid (inferior_ptid); + int status; -static void -inf_ptrace_open (char *arg, int from_tty) -{ - error ("Use the \"run\" command to start a Unix child process."); -} + if (pid == 0) + return; -/* Stub function which causes the inferior that runs it, to be ptrace-able - by its parent process. */ + ptrace (PT_KILL, pid, (PTRACE_TYPE_ARG3)0, 0); + waitpid (pid, &status, 0); -static void -inf_ptrace_me (void) -{ - /* "Trace me, Dr. Memory!" */ - ptrace (0, 0, (PTRACE_TYPE_ARG3) 0, 0); + target_mourn_inferior (); } -/* Stub function which causes the GDB that runs it, to start ptrace-ing - the child process. */ +/* Stop the inferior. */ static void -inf_ptrace_him (int pid) +inf_ptrace_stop (void) { - push_target (ptrace_ops_hack); - - /* On some targets, there must be some explicit synchronization - between the parent and child processes after the debugger - forks, and before the child execs the debuggee program. This - call basically gives permission for the child to exec. - */ - - target_acknowledge_created_inferior (pid); - - /* START_INFERIOR_TRAPS_EXPECTED is defined in inferior.h, - * and will be 1 or 2 depending on whether we're starting - * without or with a shell. - */ - startup_inferior (START_INFERIOR_TRAPS_EXPECTED); - - /* On some targets, there must be some explicit actions taken after - the inferior has been started up. - */ - target_post_startup_inferior (pid_to_ptid (pid)); + /* Send a SIGINT to the process group. This acts just like the user + typed a ^C on the controlling terminal. Note that using a + negative process number in kill() is a System V-ism. The proper + BSD interface is killpg(). However, all modern BSDs support the + System V interface too. */ + kill (-inferior_process_group, SIGINT); } -/* Start an inferior Unix child process and sets inferior_ptid to its - pid. EXEC_FILE is the file to run. ALLARGS is a string containing - the arguments to the program. ENV is the environment vector to - pass. Errors reported with error(). */ +/* Resume execution of thread PTID, or all threads if PTID is -1. If + STEP is nonzero, single-step it. If SIGNAL is nonzero, give it + that signal. */ static void -inf_ptrace_create_inferior (char *exec_file, char *allargs, char **env, - int from_tty) +inf_ptrace_resume (ptid_t ptid, int step, enum target_signal signal) { - fork_inferior (exec_file, allargs, env, inf_ptrace_me, inf_ptrace_him, - NULL, NULL); - /* We are at the first instruction we care about. */ - observer_notify_inferior_created (¤t_target, from_tty); - /* Pedal to the metal... */ - proceed ((CORE_ADDR) -1, TARGET_SIGNAL_0, 0); -} + pid_t pid = ptid_get_pid (ptid); + int request = PT_CONTINUE; -static void -inf_ptrace_post_startup_inferior (ptid_t ptid) -{ - /* This version of Unix doesn't require a meaningful "post startup inferior" - operation by a debugger. - */ -} + if (pid == -1) + /* Resume all threads. Traditionally ptrace() only supports + single-threaded processes, so simply resume the inferior. */ + pid = ptid_get_pid (inferior_ptid); -static void -inf_ptrace_acknowledge_created_inferior (int pid) -{ - /* This version of Unix doesn't require a meaningful "acknowledge created inferior" - operation by a debugger. - */ -} + if (step) + { + /* If this system does not support PT_STEP, a higher level + function will have called single_step() to transmute the step + request into a continue request (by setting breakpoints on + all possible successor instructions), so we don't have to + worry about that here. */ + request = PT_STEP; + } -static int -inf_ptrace_insert_fork_catchpoint (int pid) -{ - /* This version of Unix doesn't support notification of fork events. */ - return 0; + /* An address of (PTRACE_TYPE_ARG3)1 tells ptrace to continue from + where it was. If GDB wanted it to start some other way, we have + already written a new program counter value to the child. */ + errno = 0; + ptrace (request, pid, (PTRACE_TYPE_ARG3)1, target_signal_to_host (signal)); + if (errno != 0) + perror_with_name (("ptrace")); } -static int -inf_ptrace_remove_fork_catchpoint (int pid) -{ - /* This version of Unix doesn't support notification of fork events. */ - return 0; -} +/* Wait for the child specified by PTID to do something. Return the + process ID of the child, or MINUS_ONE_PTID in case of error; store + the status in *OURSTATUS. */ -static int -inf_ptrace_insert_vfork_catchpoint (int pid) +static ptid_t +inf_ptrace_wait (ptid_t ptid, struct target_waitstatus *ourstatus) { - /* This version of Unix doesn't support notification of vfork events. */ - return 0; -} + pid_t pid; + int status, save_errno; -static int -inf_ptrace_remove_vfork_catchpoint (int pid) -{ - /* This version of Unix doesn't support notification of vfork events. */ - return 0; -} + do + { + set_sigint_trap (); + set_sigio_trap (); -static int -inf_ptrace_follow_fork (int follow_child) -{ - /* This version of Unix doesn't support following fork or vfork events. */ - return 0; -} + do + { + pid = waitpid (ptid_get_pid (ptid), &status, 0); + save_errno = errno; + } + while (pid == -1 && errno == EINTR); -static int -inf_ptrace_insert_exec_catchpoint (int pid) -{ - /* This version of Unix doesn't support notification of exec events. */ - return 0; -} + clear_sigio_trap (); + clear_sigint_trap (); -static int -inf_ptrace_remove_exec_catchpoint (int pid) -{ - /* This version of Unix doesn't support notification of exec events. */ - return 0; -} + if (pid == -1) + { + fprintf_unfiltered (gdb_stderr, + _("Child process unexpectedly missing: %s.\n"), + safe_strerror (save_errno)); -static int -inf_ptrace_reported_exec_events_per_exec_call (void) -{ - /* This version of Unix doesn't support notification of exec events. - */ - return 1; -} + /* Claim it exited with unknown signal. */ + ourstatus->kind = TARGET_WAITKIND_SIGNALLED; + ourstatus->value.sig = TARGET_SIGNAL_UNKNOWN; + return minus_one_ptid; + } -static int -inf_ptrace_has_exited (int pid, int wait_status, int *exit_status) -{ - if (WIFEXITED (wait_status)) - { - *exit_status = WEXITSTATUS (wait_status); - return 1; + /* Ignore terminated detached child processes. */ + if (!WIFSTOPPED (status) && pid != ptid_get_pid (inferior_ptid)) + pid = -1; } + while (pid == -1); - if (WIFSIGNALED (wait_status)) +#ifdef PT_GET_PROCESS_STATE + if (WIFSTOPPED (status)) { - *exit_status = 0; /* ?? Don't know what else to say here. */ - return 1; - } - - /* ?? Do we really need to consult the event state, too? Assume the - wait_state alone suffices. - */ - return 0; -} - -static void -inf_ptrace_mourn_inferior (void) -{ - unpush_target (ptrace_ops_hack); - generic_mourn_inferior (); -} + ptrace_state_t pe; + pid_t fpid; -static int -inf_ptrace_can_run (void) -{ - return 1; -} + if (ptrace (PT_GET_PROCESS_STATE, pid, + (PTRACE_TYPE_ARG3)&pe, sizeof pe) == -1) + perror_with_name (("ptrace")); -/* Send a SIGINT to the process group. This acts just like the user - typed a ^C on the controlling terminal. + switch (pe.pe_report_event) + { + case PTRACE_FORK: + ourstatus->kind = TARGET_WAITKIND_FORKED; + ourstatus->value.related_pid = pe.pe_other_pid; + + /* Make sure the other end of the fork is stopped too. */ + fpid = waitpid (pe.pe_other_pid, &status, 0); + if (fpid == -1) + perror_with_name (("waitpid")); + + if (ptrace (PT_GET_PROCESS_STATE, fpid, + (PTRACE_TYPE_ARG3)&pe, sizeof pe) == -1) + perror_with_name (("ptrace")); + + gdb_assert (pe.pe_report_event == PTRACE_FORK); + gdb_assert (pe.pe_other_pid == pid); + if (fpid == ptid_get_pid (inferior_ptid)) + { + ourstatus->value.related_pid = pe.pe_other_pid; + return pid_to_ptid (fpid); + } - XXX - This may not be correct for all systems. Some may want to - use killpg() instead of kill (-pgrp). */ + return pid_to_ptid (pid); + } + } +#endif -static void -inf_ptrace_stop (void) -{ - kill (-inferior_process_group, SIGINT); + store_waitstatus (ourstatus, status); + return pid_to_ptid (pid); } -/* Perform a partial transfer to/from the specified object. For - memory transfers, fall back to the old memory xfer functions. */ +/* Attempt a transfer all LEN bytes starting at OFFSET between the + inferior's OBJECT:ANNEX space and GDB's READBUF/WRITEBUF buffer. + Return the number of bytes actually transferred. */ static LONGEST inf_ptrace_xfer_partial (struct target_ops *ops, enum target_object object, const char *annex, void *readbuf, - const void *writebuf, ULONGEST offset, LONGEST len) + const void *writebuf, + ULONGEST offset, LONGEST len) { + pid_t pid = ptid_get_pid (inferior_ptid); + switch (object) { case TARGET_OBJECT_MEMORY: @@ -486,16 +460,16 @@ inf_ptrace_xfer_partial (struct target_ops *ops, enum target_object object, and writing data in the traced process's address space. */ { struct ptrace_io_desc piod; - + /* NOTE: We assume that there are no distinct address spaces for instruction and data. */ - piod.piod_op = writebuf ? PIOD_WRITE_I : PIOD_READ_I; + piod.piod_op = writebuf ? PIOD_WRITE_I : PIOD_READ_D; piod.piod_addr = writebuf ? (void *) writebuf : readbuf; piod.piod_offs = (void *) (long) offset; piod.piod_len = len; errno = 0; - if (ptrace (PT_IO, PIDGET (inferior_ptid), (caddr_t) &piod, 0) == 0) + if (ptrace (PT_IO, pid, (caddr_t)&piod, 0) == 0) /* Return the actual number of bytes read or written. */ return piod.piod_len; /* If the PT_IO request is somehow not supported, fallback on @@ -509,15 +483,15 @@ inf_ptrace_xfer_partial (struct target_ops *ops, enum target_object object, union { PTRACE_TYPE_RET word; - unsigned char byte[sizeof (PTRACE_TYPE_RET)]; + char byte[sizeof (PTRACE_TYPE_RET)]; } buffer; ULONGEST rounded_offset; LONGEST partial_len; - + /* Round the start offset down to the next long word boundary. */ rounded_offset = offset & -(ULONGEST) sizeof (PTRACE_TYPE_RET); - + /* Since ptrace will transfer a single word starting at that rounded_offset the partial_len needs to be adjusted down to that (remember this function only does a single transfer). @@ -526,7 +500,7 @@ inf_ptrace_xfer_partial (struct target_ops *ops, enum target_object object, partial_len = (rounded_offset + sizeof (PTRACE_TYPE_RET)) - offset; if (partial_len > len) partial_len = len; - + if (writebuf) { /* If OFFSET:PARTIAL_LEN is smaller than @@ -536,41 +510,41 @@ inf_ptrace_xfer_partial (struct target_ops *ops, enum target_object object, || (offset + partial_len < rounded_offset + sizeof (PTRACE_TYPE_RET))) /* Need part of initial word -- fetch it. */ - buffer.word = ptrace (PT_READ_I, PIDGET (inferior_ptid), - (PTRACE_TYPE_ARG3) (long) rounded_offset, - 0); - + buffer.word = ptrace (PT_READ_I, pid, + (PTRACE_TYPE_ARG3)(long)rounded_offset, 0); + /* Copy data to be written over corresponding part of buffer. */ - memcpy (buffer.byte + (offset - rounded_offset), writebuf, partial_len); - + memcpy (buffer.byte + (offset - rounded_offset), + writebuf, partial_len); + errno = 0; - ptrace (PT_WRITE_D, PIDGET (inferior_ptid), - (PTRACE_TYPE_ARG3) (long) rounded_offset, - buffer.word); + ptrace (PT_WRITE_D, pid, + (PTRACE_TYPE_ARG3)(long)rounded_offset, buffer.word); if (errno) { /* Using the appropriate one (I or D) is necessary for Gould NP1, at least. */ errno = 0; - ptrace (PT_WRITE_I, PIDGET (inferior_ptid), - (PTRACE_TYPE_ARG3) (long) rounded_offset, - buffer.word); + ptrace (PT_WRITE_I, pid, + (PTRACE_TYPE_ARG3)(long)rounded_offset, buffer.word); if (errno) return 0; } } + if (readbuf) { errno = 0; - buffer.word = ptrace (PT_READ_I, PIDGET (inferior_ptid), - (PTRACE_TYPE_ARG3) (long) rounded_offset, 0); + buffer.word = ptrace (PT_READ_I, pid, + (PTRACE_TYPE_ARG3)(long)rounded_offset, 0); if (errno) return 0; /* Copy appropriate bytes out of the buffer. */ memcpy (readbuf, buffer.byte + (offset - rounded_offset), partial_len); } + return partial_len; } @@ -588,52 +562,173 @@ inf_ptrace_xfer_partial (struct target_ops *ops, enum target_object object, } } -static char * -inf_ptrace_pid_to_str (ptid_t ptid) +/* Return non-zero if the thread specified by PTID is alive. */ + +static int +inf_ptrace_thread_alive (ptid_t ptid) +{ + /* ??? Is kill the right way to do this? */ + return (kill (ptid_get_pid (ptid), 0) != -1); +} + +/* Print status information about what we're accessing. */ + +static void +inf_ptrace_files_info (struct target_ops *ignore) { - return normal_pid_to_str (ptid); + printf_filtered (_("\tUsing the running image of %s %s.\n"), + attach_flag ? "attached" : "child", + target_pid_to_str (inferior_ptid)); } +/* Create a prototype ptrace target. The client can override it with + local methods. */ + struct target_ops * inf_ptrace_target (void) { struct target_ops *t = inf_child_target (); - t->to_open = inf_ptrace_open; + t->to_attach = inf_ptrace_attach; - t->to_post_attach = inf_ptrace_post_attach; t->to_detach = inf_ptrace_detach; t->to_resume = inf_ptrace_resume; t->to_wait = inf_ptrace_wait; - t->to_prepare_to_store = inf_ptrace_prepare_to_store; - t->to_xfer_partial = inf_ptrace_xfer_partial; t->to_files_info = inf_ptrace_files_info; - t->to_kill = inf_ptrace_kill_inferior; + t->to_kill = inf_ptrace_kill; t->to_create_inferior = inf_ptrace_create_inferior; - t->to_post_startup_inferior = inf_ptrace_post_startup_inferior; - t->to_acknowledge_created_inferior = - inf_ptrace_acknowledge_created_inferior; - t->to_insert_fork_catchpoint = inf_ptrace_insert_fork_catchpoint; - t->to_remove_fork_catchpoint = inf_ptrace_remove_fork_catchpoint; - t->to_insert_vfork_catchpoint = inf_ptrace_insert_vfork_catchpoint; - t->to_remove_vfork_catchpoint = inf_ptrace_remove_vfork_catchpoint; +#ifdef PT_GET_PROCESS_STATE t->to_follow_fork = inf_ptrace_follow_fork; - t->to_insert_exec_catchpoint = inf_ptrace_insert_exec_catchpoint; - t->to_remove_exec_catchpoint = inf_ptrace_remove_exec_catchpoint; - t->to_reported_exec_events_per_exec_call = - inf_ptrace_reported_exec_events_per_exec_call; - t->to_has_exited = inf_ptrace_has_exited; + t->to_post_startup_inferior = inf_ptrace_post_startup_inferior; + t->to_post_attach = inf_ptrace_post_attach; +#endif t->to_mourn_inferior = inf_ptrace_mourn_inferior; - t->to_can_run = inf_ptrace_can_run; t->to_thread_alive = inf_ptrace_thread_alive; - t->to_pid_to_str = inf_ptrace_pid_to_str; + t->to_pid_to_str = normal_pid_to_str; t->to_stop = inf_ptrace_stop; - t->to_stratum = process_stratum; - t->to_has_all_memory = 1; - t->to_has_memory = 1; - t->to_has_stack = 1; - t->to_has_registers = 1; - t->to_has_execution = 1; - t->to_magic = OPS_MAGIC; + t->to_xfer_partial = inf_ptrace_xfer_partial; + ptrace_ops_hack = t; return t; } + + +/* Pointer to a function that returns the offset within the user area + where a particular register is stored. */ +static CORE_ADDR (*inf_ptrace_register_u_offset)(int); + +/* Fetch register REGNUM from the inferior. */ + +static void +inf_ptrace_fetch_register (int regnum) +{ + CORE_ADDR addr; + size_t size; + PTRACE_TYPE_RET *buf; + int pid, i; + + /* Cater for systems like GNU/Linux, that implement threads as + seperate processes. */ + pid = ptid_get_lwp (inferior_ptid); + if (pid == 0) + pid = ptid_get_pid (inferior_ptid); + + /* This isn't really an address, but ptrace thinks of it as one. */ + addr = inf_ptrace_register_u_offset (regnum); + size = register_size (current_gdbarch, regnum); + + gdb_assert ((size % sizeof (PTRACE_TYPE_RET)) == 0); + buf = alloca (size); + + /* Read the register contents from the inferior a chuck at the time. */ + for (i = 0; i < size / sizeof (PTRACE_TYPE_RET); i++) + { + errno = 0; + buf[i] = ptrace (PT_READ_U, pid, (PTRACE_TYPE_ARG3)addr, 0); + if (errno != 0) + error (_("Couldn't read register %s (#%d): %s."), + REGISTER_NAME (regnum), regnum, safe_strerror (errno)); + + addr += sizeof (PTRACE_TYPE_RET); + } + regcache_raw_supply (current_regcache, regnum, buf); +} + +/* Fetch register REGNUM from the inferior. If REGNUM is -1, do this + for all registers. */ + +static void +inf_ptrace_fetch_registers (int regnum) +{ + if (regnum == -1) + for (regnum = 0; regnum < NUM_REGS; regnum++) + inf_ptrace_fetch_register (regnum); + else + inf_ptrace_fetch_register (regnum); +} + +/* Store register REGNUM into the inferior. */ + +static void +inf_ptrace_store_register (int regnum) +{ + CORE_ADDR addr; + size_t size; + PTRACE_TYPE_RET *buf; + int pid, i; + + /* Cater for systems like GNU/Linux, that implement threads as + seperate processes. */ + pid = ptid_get_lwp (inferior_ptid); + if (pid == 0) + pid = ptid_get_pid (inferior_ptid); + + /* This isn't really an address, but ptrace thinks of it as one. */ + addr = inf_ptrace_register_u_offset (regnum); + size = register_size (current_gdbarch, regnum); + + gdb_assert ((size % sizeof (PTRACE_TYPE_RET)) == 0); + buf = alloca (size); + + /* Write the register contents into the inferior a chunk at the time. */ + regcache_raw_collect (current_regcache, regnum, buf); + for (i = 0; i < size / sizeof (PTRACE_TYPE_RET); i++) + { + errno = 0; + ptrace (PT_WRITE_U, pid, (PTRACE_TYPE_ARG3)addr, buf[i]); + if (errno != 0) + error (_("Couldn't write register %s (#%d): %s."), + REGISTER_NAME (regnum), regnum, safe_strerror (errno)); + + addr += sizeof (PTRACE_TYPE_RET); + } +} + +/* Store register REGNUM back into the inferior. If REGNUM is -1, do + this for all registers. */ + +void +inf_ptrace_store_registers (int regnum) +{ + if (regnum == -1) + for (regnum = 0; regnum < NUM_REGS; regnum++) + inf_ptrace_store_register (regnum); + else + inf_ptrace_store_register (regnum); +} + +/* Create a "traditional" ptrace target. REGISTER_U_OFFSET should be + a function returning the offset within the user area where a + particular register is stored. */ + +struct target_ops * +inf_ptrace_trad_target (CORE_ADDR (*register_u_offset)(int)) +{ + struct target_ops *t = inf_ptrace_target(); + + gdb_assert (register_u_offset); + inf_ptrace_register_u_offset = register_u_offset; + t->to_fetch_registers = inf_ptrace_fetch_registers; + t->to_store_registers = inf_ptrace_store_registers; + + return t; +} |