X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=gdb%2Finf-ptrace.c;h=a83ffcc87989b90416c4df58378dc26f883d3136;hb=refs%2Fheads%2Fconcurrent-displaced-stepping-2020-04-01;hp=4c22a84ba4d78f9f85db711d9175cf5f3d3017ed;hpb=ebf3aa72243fec4bc02617673b243a63050e6127;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/inf-ptrace.c b/gdb/inf-ptrace.c index 4c22a84ba4..a83ffcc879 100644 --- a/gdb/inf-ptrace.c +++ b/gdb/inf-ptrace.c @@ -1,6 +1,6 @@ /* Low-level child interface to ptrace. - Copyright (C) 1988-2015 Free Software Foundation, Inc. + Copyright (C) 1988-2020 Free Software Foundation, Inc. This file is part of GDB. @@ -24,41 +24,50 @@ #include "terminal.h" #include "gdbcore.h" #include "regcache.h" -#include "gdb_ptrace.h" -#include "gdb_wait.h" +#include "nat/gdb_ptrace.h" +#include "gdbsupport/gdb_wait.h" #include #include "inf-ptrace.h" #include "inf-child.h" #include "gdbthread.h" +#include "nat/fork-inferior.h" +#include "utils.h" +#include "gdbarch.h" -#ifdef PT_GET_PROCESS_STATE +static PTRACE_TYPE_RET +gdb_ptrace (PTRACE_TYPE_ARG1 request, ptid_t ptid, PTRACE_TYPE_ARG3 addr, + PTRACE_TYPE_ARG4 data) +{ +#ifdef __NetBSD__ + return ptrace (request, ptid.pid (), addr, data); +#else + pid_t pid = get_ptrace_pid (ptid); + return ptrace (request, pid, addr, data); +#endif +} -/* Target hook for follow_fork. On entry and at return inferior_ptid is - the ptid of the followed inferior. */ +/* A unique_ptr helper to unpush a target. */ -static int -inf_ptrace_follow_fork (struct target_ops *ops, int follow_child, - int detach_fork) +struct target_unpusher { - if (!follow_child) - { - struct thread_info *tp = inferior_thread (); - pid_t child_pid = ptid_get_pid (tp->pending_follow.value.related_pid); + void operator() (struct target_ops *ops) const + { + unpush_target (ops); + } +}; - /* Breakpoints have already been detached from the child by - infrun.c. */ +/* A unique_ptr that unpushes a target on destruction. */ - if (ptrace (PT_DETACH, child_pid, (PTRACE_TYPE_ARG3)1, 0) == -1) - perror_with_name (("ptrace")); - } +typedef std::unique_ptr target_unpush_up; - return 0; -} + + +inf_ptrace_target::~inf_ptrace_target () +{} -#endif /* PT_GET_PROCESS_STATE */ /* Prepare to be traced. */ @@ -67,7 +76,8 @@ static void inf_ptrace_me (void) { /* "Trace me, Dr. Memory!" */ - ptrace (PT_TRACE_ME, 0, (PTRACE_TYPE_ARG3)0, 0); + if (ptrace (PT_TRACE_ME, 0, (PTRACE_TYPE_ARG3) 0, 0) < 0) + trace_start_error_with_name ("ptrace"); } /* Start a new inferior Unix child process. EXEC_FILE is the file to @@ -75,58 +85,48 @@ inf_ptrace_me (void) ENV is the environment vector to pass. If FROM_TTY is non-zero, be chatty about it. */ -static void -inf_ptrace_create_inferior (struct target_ops *ops, - char *exec_file, char *allargs, char **env, - int from_tty) +void +inf_ptrace_target::create_inferior (const char *exec_file, + const std::string &allargs, + char **env, int from_tty) { - int pid; + pid_t pid; + ptid_t ptid; /* Do not change either targets above or the same target if already present. The reason is the target stack is shared across multiple inferiors. */ - int ops_already_pushed = target_is_pushed (ops); - struct cleanup *back_to = make_cleanup (null_cleanup, NULL); + int ops_already_pushed = target_is_pushed (this); + target_unpush_up unpusher; if (! ops_already_pushed) { /* Clear possible core file with its process_stratum. */ - push_target (ops); - make_cleanup_unpush_target (ops); + push_target (this); + unpusher.reset (this); } pid = fork_inferior (exec_file, allargs, env, inf_ptrace_me, NULL, NULL, NULL, NULL); - discard_cleanups (back_to); + ptid = ptid_t (pid); + /* We have something that executes now. We'll be running through + the shell at this point (if startup-with-shell is true), but the + pid shouldn't change. */ + add_thread_silent (this, ptid); - startup_inferior (START_INFERIOR_TRAPS_EXPECTED); + unpusher.release (); + + gdb_startup_inferior (pid, 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)); -} - -#ifdef PT_GET_PROCESS_STATE - -static void -inf_ptrace_post_startup_inferior (struct target_ops *self, 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")); + target_post_startup_inferior (ptid); } -#endif - /* Clean up a rotting corpse of an inferior after it died. */ -static void -inf_ptrace_mourn_inferior (struct target_ops *ops) +void +inf_ptrace_target::mourn_inferior () { int status; @@ -134,51 +134,48 @@ inf_ptrace_mourn_inferior (struct target_ops *ops) Do 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 original parent. */ - waitpid (ptid_get_pid (inferior_ptid), &status, 0); + waitpid (inferior_ptid.pid (), &status, 0); - inf_child_mourn_inferior (ops); + inf_child_target::mourn_inferior (); } /* Attach to the process specified by ARGS. If FROM_TTY is non-zero, be chatty about it. */ -static void -inf_ptrace_attach (struct target_ops *ops, const char *args, int from_tty) +void +inf_ptrace_target::attach (const char *args, int from_tty) { - char *exec_file; pid_t pid; struct inferior *inf; /* Do not change either targets above or the same target if already present. The reason is the target stack is shared across multiple inferiors. */ - int ops_already_pushed = target_is_pushed (ops); - struct cleanup *back_to = make_cleanup (null_cleanup, NULL); + int ops_already_pushed = target_is_pushed (this); pid = parse_pid_to_attach (args); if (pid == getpid ()) /* Trying to masturbate? */ error (_("I refuse to debug myself!")); + target_unpush_up unpusher; if (! ops_already_pushed) { /* target_pid_to_str already uses the target. Also clear possible core file with its process_stratum. */ - push_target (ops); - make_cleanup_unpush_target (ops); + push_target (this); + unpusher.reset (this); } if (from_tty) { - exec_file = get_exec_file (0); + const char *exec_file = get_exec_file (0); if (exec_file) printf_unfiltered (_("Attaching to program: %s, %s\n"), exec_file, - target_pid_to_str (pid_to_ptid (pid))); + target_pid_to_str (ptid_t (pid)).c_str ()); else printf_unfiltered (_("Attaching to %s\n"), - target_pid_to_str (pid_to_ptid (pid))); - - gdb_flush (gdb_stdout); + target_pid_to_str (ptid_t (pid)).c_str ()); } #ifdef PT_ATTACH @@ -193,52 +190,26 @@ inf_ptrace_attach (struct target_ops *ops, const char *args, int from_tty) inf = current_inferior (); inferior_appeared (inf, pid); inf->attach_flag = 1; - inferior_ptid = pid_to_ptid (pid); + inferior_ptid = ptid_t (pid); /* Always add a main thread. If some target extends the ptrace target, it should decorate the ptid later with more info. */ - add_thread_silent (inferior_ptid); + thread_info *thr = add_thread_silent (this, inferior_ptid); + /* Don't consider the thread stopped until we've processed its + initial SIGSTOP stop. */ + set_executing (this, thr->ptid, true); - discard_cleanups (back_to); + unpusher.release (); } -#ifdef PT_GET_PROCESS_STATE +/* Detach from the inferior. If FROM_TTY is non-zero, be chatty about it. */ -static void -inf_ptrace_post_attach (struct target_ops *self, int pid) +void +inf_ptrace_target::detach (inferior *inf, int from_tty) { - ptrace_event_t pe; + pid_t pid = inferior_ptid.pid (); - /* 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")); -} - -#endif - -/* Detach from the inferior, optionally passing it the signal - specified by ARGS. If FROM_TTY is non-zero, be chatty about it. */ - -static void -inf_ptrace_detach (struct target_ops *ops, const char *args, int from_tty) -{ - pid_t pid = ptid_get_pid (inferior_ptid); - int sig = 0; - - 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, - target_pid_to_str (pid_to_ptid (pid))); - gdb_flush (gdb_stdout); - } - if (args) - sig = atoi (args); + target_announce_detach (from_tty); #ifdef PT_DETACH /* We'd better not have left any breakpoints in the program or it'll @@ -246,25 +217,33 @@ inf_ptrace_detach (struct target_ops *ops, const char *args, int from_tty) 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, 0); if (errno != 0) perror_with_name (("ptrace")); #else error (_("This system does not support detaching from a process")); #endif + detach_success (inf); +} + +/* See inf-ptrace.h. */ + +void +inf_ptrace_target::detach_success (inferior *inf) +{ inferior_ptid = null_ptid; - detach_inferior (pid); + detach_inferior (inf); - inf_child_maybe_unpush_target (ops); + maybe_unpush_target (); } /* Kill the inferior. */ -static void -inf_ptrace_kill (struct target_ops *ops) +void +inf_ptrace_target::kill () { - pid_t pid = ptid_get_pid (inferior_ptid); + pid_t pid = inferior_ptid.pid (); int status; if (pid == 0) @@ -273,37 +252,40 @@ inf_ptrace_kill (struct target_ops *ops) ptrace (PT_KILL, pid, (PTRACE_TYPE_ARG3)0, 0); waitpid (pid, &status, 0); - target_mourn_inferior (); + target_mourn_inferior (inferior_ptid); } -/* Stop the inferior. */ +#ifndef __NetBSD__ -static void -inf_ptrace_stop (struct target_ops *self, ptid_t ptid) +/* See inf-ptrace.h. */ + +pid_t +get_ptrace_pid (ptid_t ptid) { - /* 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); + pid_t pid; + + /* If we have an LWPID to work with, use it. Otherwise, we're + dealing with a non-threaded program/target. */ + pid = ptid.lwp (); + if (pid == 0) + pid = ptid.pid (); + return pid; } +#endif /* 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_resume (struct target_ops *ops, - ptid_t ptid, int step, enum gdb_signal signal) +void +inf_ptrace_target::resume (ptid_t ptid, int step, enum gdb_signal signal) { - pid_t pid = ptid_get_pid (ptid); - int request; + PTRACE_TYPE_ARG1 request; - if (pid == -1) + if (minus_one_ptid == ptid) /* Resume all threads. Traditionally ptrace() only supports single-threaded processes, so simply resume the inferior. */ - pid = ptid_get_pid (inferior_ptid); + ptid = ptid_t (inferior_ptid.pid ()); if (catch_syscall_enabled () > 0) request = PT_SYSCALL; @@ -313,10 +295,10 @@ inf_ptrace_resume (struct target_ops *ops, 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. */ + function will have called the appropriate functions 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; } @@ -324,7 +306,7 @@ inf_ptrace_resume (struct target_ops *ops, 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, gdb_signal_to_host (signal)); + gdb_ptrace (request, ptid, (PTRACE_TYPE_ARG3)1, gdb_signal_to_host (signal)); if (errno != 0) perror_with_name (("ptrace")); } @@ -333,9 +315,9 @@ inf_ptrace_resume (struct target_ops *ops, process ID of the child, or MINUS_ONE_PTID in case of error; store the status in *OURSTATUS. */ -static ptid_t -inf_ptrace_wait (struct target_ops *ops, - ptid_t ptid, struct target_waitstatus *ourstatus, int options) +ptid_t +inf_ptrace_target::wait (ptid_t ptid, struct target_waitstatus *ourstatus, + int options) { pid_t pid; int status, save_errno; @@ -346,7 +328,7 @@ inf_ptrace_wait (struct target_ops *ops, do { - pid = waitpid (ptid_get_pid (ptid), &status, 0); + pid = waitpid (ptid.pid (), &status, 0); save_errno = errno; } while (pid == -1 && errno == EINTR); @@ -366,62 +348,90 @@ inf_ptrace_wait (struct target_ops *ops, } /* Ignore terminated detached child processes. */ - if (!WIFSTOPPED (status) && pid != ptid_get_pid (inferior_ptid)) + if (!WIFSTOPPED (status) && pid != inferior_ptid.pid ()) pid = -1; } while (pid == -1); -#ifdef PT_GET_PROCESS_STATE - if (WIFSTOPPED (status)) + store_waitstatus (ourstatus, status); + return ptid_t (pid); +} + +/* Transfer data via ptrace into process PID's memory from WRITEBUF, or + from process PID's memory into READBUF. Start at target address ADDR + and transfer up to LEN bytes. Exactly one of READBUF and WRITEBUF must + be non-null. Return the number of transferred bytes. */ + +static ULONGEST +inf_ptrace_peek_poke (ptid_t ptid, gdb_byte *readbuf, + const gdb_byte *writebuf, + ULONGEST addr, ULONGEST len) +{ + ULONGEST n; + unsigned int chunk; + + /* We transfer aligned words. Thus align ADDR down to a word + boundary and determine how many bytes to skip at the + beginning. */ + ULONGEST skip = addr & (sizeof (PTRACE_TYPE_RET) - 1); + addr -= skip; + + for (n = 0; + n < len; + n += chunk, addr += sizeof (PTRACE_TYPE_RET), skip = 0) { - ptrace_state_t pe; - pid_t fpid; + /* Restrict to a chunk that fits in the current word. */ + chunk = std::min (sizeof (PTRACE_TYPE_RET) - skip, len - n); - if (ptrace (PT_GET_PROCESS_STATE, pid, - (PTRACE_TYPE_ARG3)&pe, sizeof pe) == -1) - perror_with_name (("ptrace")); + /* Use a union for type punning. */ + union + { + PTRACE_TYPE_RET word; + gdb_byte byte[sizeof (PTRACE_TYPE_RET)]; + } buf; - switch (pe.pe_report_event) + /* Read the word, also when doing a partial word write. */ + if (readbuf != NULL || chunk < sizeof (PTRACE_TYPE_RET)) { - case PTRACE_FORK: - ourstatus->kind = TARGET_WAITKIND_FORKED; - ourstatus->value.related_pid = pid_to_ptid (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)) + errno = 0; + buf.word = gdb_ptrace (PT_READ_I, ptid, + (PTRACE_TYPE_ARG3)(uintptr_t) addr, 0); + if (errno != 0) + break; + if (readbuf != NULL) + memcpy (readbuf + n, buf.byte + skip, chunk); + } + if (writebuf != NULL) + { + memcpy (buf.byte + skip, writebuf + n, chunk); + errno = 0; + gdb_ptrace (PT_WRITE_D, ptid, (PTRACE_TYPE_ARG3)(uintptr_t) addr, + buf.word); + if (errno != 0) { - ourstatus->value.related_pid = pid_to_ptid (pe.pe_other_pid); - return pid_to_ptid (fpid); + /* Using the appropriate one (I or D) is necessary for + Gould NP1, at least. */ + errno = 0; + gdb_ptrace (PT_WRITE_I, ptid, (PTRACE_TYPE_ARG3)(uintptr_t) addr, + buf.word); + if (errno != 0) + break; } - - return pid_to_ptid (pid); } } -#endif - store_waitstatus (ourstatus, status); - return pid_to_ptid (pid); + return n; } /* Implement the to_xfer_partial target_ops method. */ -static enum target_xfer_status -inf_ptrace_xfer_partial (struct target_ops *ops, enum target_object object, - const char *annex, gdb_byte *readbuf, - const gdb_byte *writebuf, - ULONGEST offset, ULONGEST len, ULONGEST *xfered_len) +enum target_xfer_status +inf_ptrace_target::xfer_partial (enum target_object object, + const char *annex, gdb_byte *readbuf, + const gdb_byte *writebuf, + ULONGEST offset, ULONGEST len, ULONGEST *xfered_len) { - pid_t pid = ptid_get_pid (inferior_ptid); + ptid_t ptid = inferior_ptid; switch (object) { @@ -445,7 +455,7 @@ inf_ptrace_xfer_partial (struct target_ops *ops, enum target_object object, piod.piod_len = len; errno = 0; - if (ptrace (PT_IO, pid, (caddr_t)&piod, 0) == 0) + if (gdb_ptrace (PT_IO, ptid, (caddr_t)&piod, 0) == 0) { /* Return the actual number of bytes read or written. */ *xfered_len = piod.piod_len; @@ -458,79 +468,9 @@ inf_ptrace_xfer_partial (struct target_ops *ops, enum target_object object, return TARGET_XFER_EOF; } #endif - { - union - { - PTRACE_TYPE_RET word; - gdb_byte byte[sizeof (PTRACE_TYPE_RET)]; - } buffer; - ULONGEST rounded_offset; - ULONGEST 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). - Should the required length be even less, adjust it down - again. */ - 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 - ROUNDED_OFFSET:WORDSIZE then a read/modify write will - be needed. Read in the entire word. */ - if (rounded_offset < offset - || (offset + partial_len - < rounded_offset + sizeof (PTRACE_TYPE_RET))) - /* Need part of initial word -- fetch it. */ - buffer.word = ptrace (PT_READ_I, pid, - (PTRACE_TYPE_ARG3)(uintptr_t) - rounded_offset, 0); - - /* Copy data to be written over corresponding part of - buffer. */ - memcpy (buffer.byte + (offset - rounded_offset), - writebuf, partial_len); - - errno = 0; - ptrace (PT_WRITE_D, pid, - (PTRACE_TYPE_ARG3)(uintptr_t)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, pid, - (PTRACE_TYPE_ARG3)(uintptr_t)rounded_offset, - buffer.word); - if (errno) - return TARGET_XFER_EOF; - } - } - - if (readbuf) - { - errno = 0; - buffer.word = ptrace (PT_READ_I, pid, - (PTRACE_TYPE_ARG3)(uintptr_t)rounded_offset, - 0); - if (errno) - return TARGET_XFER_EOF; - /* Copy appropriate bytes out of the buffer. */ - memcpy (readbuf, buffer.byte + (offset - rounded_offset), - partial_len); - } - - *xfered_len = partial_len; - return TARGET_XFER_OK; - } + *xfered_len = inf_ptrace_peek_poke (ptid, readbuf, writebuf, + offset, len); + return *xfered_len != 0 ? TARGET_XFER_OK : TARGET_XFER_EOF; case TARGET_OBJECT_UNWIND_TABLE: return TARGET_XFER_E_IO; @@ -551,7 +491,7 @@ inf_ptrace_xfer_partial (struct target_ops *ops, enum target_object object, piod.piod_len = len; errno = 0; - if (ptrace (PT_IO, pid, (caddr_t)&piod, 0) == 0) + if (gdb_ptrace (PT_IO, ptid, (caddr_t)&piod, 0) == 0) { /* Return the actual number of bytes read or written. */ *xfered_len = piod.piod_len; @@ -571,236 +511,27 @@ inf_ptrace_xfer_partial (struct target_ops *ops, enum target_object object, /* Return non-zero if the thread specified by PTID is alive. */ -static int -inf_ptrace_thread_alive (struct target_ops *ops, ptid_t ptid) +bool +inf_ptrace_target::thread_alive (ptid_t ptid) { /* ??? Is kill the right way to do this? */ - return (kill (ptid_get_pid (ptid), 0) != -1); + return (::kill (ptid.pid (), 0) != -1); } /* Print status information about what we're accessing. */ -static void -inf_ptrace_files_info (struct target_ops *ignore) +void +inf_ptrace_target::files_info () { struct inferior *inf = current_inferior (); printf_filtered (_("\tUsing the running image of %s %s.\n"), inf->attach_flag ? "attached" : "child", - target_pid_to_str (inferior_ptid)); + target_pid_to_str (inferior_ptid).c_str ()); } -static char * -inf_ptrace_pid_to_str (struct target_ops *ops, ptid_t ptid) +std::string +inf_ptrace_target::pid_to_str (ptid_t ptid) { return normal_pid_to_str (ptid); } - -#if defined (PT_IO) && defined (PIOD_READ_AUXV) - -/* Read one auxv entry from *READPTR, not reading locations >= ENDPTR. - Return 0 if *READPTR is already at the end of the buffer. - Return -1 if there is insufficient buffer for a whole entry. - Return 1 if an entry was read into *TYPEP and *VALP. */ - -static int -inf_ptrace_auxv_parse (struct target_ops *ops, gdb_byte **readptr, - gdb_byte *endptr, CORE_ADDR *typep, CORE_ADDR *valp) -{ - struct type *int_type = builtin_type (target_gdbarch ())->builtin_int; - struct type *ptr_type = builtin_type (target_gdbarch ())->builtin_data_ptr; - const int sizeof_auxv_type = TYPE_LENGTH (int_type); - const int sizeof_auxv_val = TYPE_LENGTH (ptr_type); - enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ()); - gdb_byte *ptr = *readptr; - - if (endptr == ptr) - return 0; - - if (endptr - ptr < 2 * sizeof_auxv_val) - return -1; - - *typep = extract_unsigned_integer (ptr, sizeof_auxv_type, byte_order); - ptr += sizeof_auxv_val; /* Alignment. */ - *valp = extract_unsigned_integer (ptr, sizeof_auxv_val, byte_order); - ptr += sizeof_auxv_val; - - *readptr = ptr; - return 1; -} - -#endif - -/* 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_attach = inf_ptrace_attach; - t->to_detach = inf_ptrace_detach; - t->to_resume = inf_ptrace_resume; - t->to_wait = inf_ptrace_wait; - t->to_files_info = inf_ptrace_files_info; - t->to_kill = inf_ptrace_kill; - t->to_create_inferior = inf_ptrace_create_inferior; -#ifdef PT_GET_PROCESS_STATE - t->to_follow_fork = inf_ptrace_follow_fork; - 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_thread_alive = inf_ptrace_thread_alive; - t->to_pid_to_str = inf_ptrace_pid_to_str; - t->to_stop = inf_ptrace_stop; - t->to_xfer_partial = inf_ptrace_xfer_partial; -#if defined (PT_IO) && defined (PIOD_READ_AUXV) - t->to_auxv_parse = inf_ptrace_auxv_parse; -#endif - - 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)(struct gdbarch *, int, int); - -/* Fetch register REGNUM from the inferior. */ - -static void -inf_ptrace_fetch_register (struct regcache *regcache, int regnum) -{ - struct gdbarch *gdbarch = get_regcache_arch (regcache); - CORE_ADDR addr; - size_t size; - PTRACE_TYPE_RET *buf; - int pid, i; - - /* This isn't really an address, but ptrace thinks of it as one. */ - addr = inf_ptrace_register_u_offset (gdbarch, regnum, 0); - if (addr == (CORE_ADDR)-1 - || gdbarch_cannot_fetch_register (gdbarch, regnum)) - { - regcache_raw_supply (regcache, regnum, NULL); - return; - } - - /* Cater for systems like GNU/Linux, that implement threads as - separate processes. */ - pid = ptid_get_lwp (inferior_ptid); - if (pid == 0) - pid = ptid_get_pid (inferior_ptid); - - size = register_size (gdbarch, regnum); - gdb_assert ((size % sizeof (PTRACE_TYPE_RET)) == 0); - buf = alloca (size); - - /* Read the register contents from the inferior a chunk at a time. */ - for (i = 0; i < size / sizeof (PTRACE_TYPE_RET); i++) - { - errno = 0; - buf[i] = ptrace (PT_READ_U, pid, (PTRACE_TYPE_ARG3)(uintptr_t)addr, 0); - if (errno != 0) - error (_("Couldn't read register %s (#%d): %s."), - gdbarch_register_name (gdbarch, regnum), - regnum, safe_strerror (errno)); - - addr += sizeof (PTRACE_TYPE_RET); - } - regcache_raw_supply (regcache, regnum, buf); -} - -/* Fetch register REGNUM from the inferior. If REGNUM is -1, do this - for all registers. */ - -static void -inf_ptrace_fetch_registers (struct target_ops *ops, - struct regcache *regcache, int regnum) -{ - if (regnum == -1) - for (regnum = 0; - regnum < gdbarch_num_regs (get_regcache_arch (regcache)); - regnum++) - inf_ptrace_fetch_register (regcache, regnum); - else - inf_ptrace_fetch_register (regcache, regnum); -} - -/* Store register REGNUM into the inferior. */ - -static void -inf_ptrace_store_register (const struct regcache *regcache, int regnum) -{ - struct gdbarch *gdbarch = get_regcache_arch (regcache); - CORE_ADDR addr; - size_t size; - PTRACE_TYPE_RET *buf; - int pid, i; - - /* This isn't really an address, but ptrace thinks of it as one. */ - addr = inf_ptrace_register_u_offset (gdbarch, regnum, 1); - if (addr == (CORE_ADDR)-1 - || gdbarch_cannot_store_register (gdbarch, regnum)) - return; - - /* Cater for systems like GNU/Linux, that implement threads as - separate processes. */ - pid = ptid_get_lwp (inferior_ptid); - if (pid == 0) - pid = ptid_get_pid (inferior_ptid); - - size = register_size (gdbarch, regnum); - gdb_assert ((size % sizeof (PTRACE_TYPE_RET)) == 0); - buf = alloca (size); - - /* Write the register contents into the inferior a chunk at a time. */ - regcache_raw_collect (regcache, regnum, buf); - for (i = 0; i < size / sizeof (PTRACE_TYPE_RET); i++) - { - errno = 0; - ptrace (PT_WRITE_U, pid, (PTRACE_TYPE_ARG3)(uintptr_t)addr, buf[i]); - if (errno != 0) - error (_("Couldn't write register %s (#%d): %s."), - gdbarch_register_name (gdbarch, 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. */ - -static void -inf_ptrace_store_registers (struct target_ops *ops, - struct regcache *regcache, int regnum) -{ - if (regnum == -1) - for (regnum = 0; - regnum < gdbarch_num_regs (get_regcache_arch (regcache)); - regnum++) - inf_ptrace_store_register (regcache, regnum); - else - inf_ptrace_store_register (regcache, 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) - (struct gdbarch *, int, 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; -}