X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=gdb%2Finf-ptrace.c;h=ecd82ada4ed3deaa5cfed5c575a51fdd830c338a;hb=5b6d1e4fa4fc6827c7b3f0e99ff120dfa14d65d2;hp=cd58dfb83ca9e4d69b6ac28fa06379595c8385a0;hpb=e85e8e5effcfa1a1834fdbf899e167da6dccd2cd;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/inf-ptrace.c b/gdb/inf-ptrace.c index cd58dfb83c..ecd82ada4e 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,29 +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" +/* A unique_ptr helper to unpush a target. */ + +struct target_unpusher +{ + void operator() (struct target_ops *ops) const + { + unpush_target (ops); + } +}; + +/* A unique_ptr that unpushes a target on destruction. */ + +typedef std::unique_ptr target_unpush_up; + + + +inf_ptrace_target::~inf_ptrace_target () +{} + #ifdef PT_GET_PROCESS_STATE /* Target hook for follow_fork. On entry and at return inferior_ptid is the ptid of the followed inferior. */ -static int -inf_ptrace_follow_fork (struct target_ops *ops, int follow_child, - int detach_fork) +int +inf_ptrace_target::follow_fork (int follow_child, int detach_fork) { if (!follow_child) { struct thread_info *tp = inferior_thread (); - pid_t child_pid = ptid_get_pid (tp->pending_follow.value.related_pid); + pid_t child_pid = tp->pending_follow.value.related_pid.pid (); /* Breakpoints have already been detached from the child by infrun.c. */ @@ -58,14 +79,14 @@ inf_ptrace_follow_fork (struct target_ops *ops, int follow_child, return 0; } -static int -inf_ptrace_insert_fork_catchpoint (struct target_ops *self, int pid) +int +inf_ptrace_target::insert_fork_catchpoint (int pid) { return 0; } -static int -inf_ptrace_remove_fork_catchpoint (struct target_ops *self, int pid) +int +inf_ptrace_target::remove_fork_catchpoint (int pid) { return 0; } @@ -79,7 +100,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 @@ -87,48 +109,55 @@ 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); + + unpusher.release (); - startup_inferior (START_INFERIOR_TRAPS_EXPECTED); + 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)); + target_post_startup_inferior (ptid); } #ifdef PT_GET_PROCESS_STATE -static void -inf_ptrace_post_startup_inferior (struct target_ops *self, ptid_t pid) +void +inf_ptrace_target::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), + if (ptrace (PT_SET_EVENT_MASK, pid.pid (), (PTRACE_TYPE_ARG3)&pe, sizeof pe) == -1) perror_with_name (("ptrace")); } @@ -137,8 +166,8 @@ inf_ptrace_post_startup_inferior (struct target_ops *self, ptid_t pid) /* 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; @@ -146,51 +175,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 @@ -205,19 +231,22 @@ 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 -static void -inf_ptrace_post_attach (struct target_ops *self, int pid) +void +inf_ptrace_target::post_attach (int pid) { ptrace_event_t pe; @@ -231,26 +260,14 @@ inf_ptrace_post_attach (struct target_ops *self, int pid) #endif -/* Detach from the inferior, optionally passing it the signal - specified by ARGS. If FROM_TTY is non-zero, be chatty about it. */ +/* Detach from the inferior. 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) +void +inf_ptrace_target::detach (inferior *inf, int from_tty) { - pid_t pid = ptid_get_pid (inferior_ptid); - int sig = 0; + pid_t pid = inferior_ptid.pid (); - 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 @@ -258,25 +275,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) @@ -285,35 +310,22 @@ inf_ptrace_kill (struct target_ops *ops) ptrace (PT_KILL, pid, (PTRACE_TYPE_ARG3)0, 0); waitpid (pid, &status, 0); - target_mourn_inferior (); -} - -/* Stop the inferior. */ - -static void -inf_ptrace_stop (struct target_ops *self, 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); + target_mourn_inferior (inferior_ptid); } /* Return which PID to pass to ptrace in order to observe/control the tracee identified by PTID. */ -static pid_t +pid_t get_ptrace_pid (ptid_t ptid) { 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_get_lwp (ptid); + pid = ptid.lwp (); if (pid == 0) - pid = ptid_get_pid (ptid); + pid = ptid.pid (); return pid; } @@ -321,17 +333,16 @@ get_ptrace_pid (ptid_t ptid) 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; int request; - if (ptid_equal (minus_one_ptid, ptid)) + 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); + pid = inferior_ptid.pid (); else pid = get_ptrace_pid (ptid); @@ -363,9 +374,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; @@ -376,7 +387,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); @@ -396,7 +407,7 @@ 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); @@ -415,7 +426,7 @@ inf_ptrace_wait (struct target_ops *ops, { case PTRACE_FORK: ourstatus->kind = TARGET_WAITKIND_FORKED; - ourstatus->value.related_pid = pid_to_ptid (pe.pe_other_pid); + ourstatus->value.related_pid = ptid_t (pe.pe_other_pid); /* Make sure the other end of the fork is stopped too. */ fpid = waitpid (pe.pe_other_pid, &status, 0); @@ -428,30 +439,96 @@ inf_ptrace_wait (struct target_ops *ops, gdb_assert (pe.pe_report_event == PTRACE_FORK); gdb_assert (pe.pe_other_pid == pid); - if (fpid == ptid_get_pid (inferior_ptid)) + if (fpid == inferior_ptid.pid ()) { - ourstatus->value.related_pid = pid_to_ptid (pe.pe_other_pid); - return pid_to_ptid (fpid); + ourstatus->value.related_pid = ptid_t (pe.pe_other_pid); + return ptid_t (fpid); } - return pid_to_ptid (pid); + return ptid_t (pid); } } #endif store_waitstatus (ourstatus, status); - return pid_to_ptid (pid); + 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 (pid_t pid, 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) + { + /* Restrict to a chunk that fits in the current word. */ + chunk = std::min (sizeof (PTRACE_TYPE_RET) - skip, len - n); + + /* Use a union for type punning. */ + union + { + PTRACE_TYPE_RET word; + gdb_byte byte[sizeof (PTRACE_TYPE_RET)]; + } buf; + + /* Read the word, also when doing a partial word write. */ + if (readbuf != NULL || chunk < sizeof (PTRACE_TYPE_RET)) + { + errno = 0; + buf.word = ptrace (PT_READ_I, pid, + (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; + ptrace (PT_WRITE_D, pid, (PTRACE_TYPE_ARG3)(uintptr_t) addr, + buf.word); + if (errno != 0) + { + /* 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) addr, + buf.word); + if (errno != 0) + break; + } + } + } + + 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); + pid_t pid = get_ptrace_pid (inferior_ptid); switch (object) { @@ -488,79 +565,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 (pid, readbuf, writebuf, + offset, len); + return *xfered_len != 0 ? TARGET_XFER_OK : TARGET_XFER_EOF; case TARGET_OBJECT_UNWIND_TABLE: return TARGET_XFER_E_IO; @@ -601,27 +608,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); } @@ -633,9 +640,9 @@ inf_ptrace_pid_to_str (struct target_ops *ops, ptid_t ptid) 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) +int +inf_ptrace_target::auxv_parse (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; @@ -660,179 +667,4 @@ inf_ptrace_auxv_parse (struct target_ops *ops, gdb_byte **readptr, } #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_insert_fork_catchpoint = inf_ptrace_insert_fork_catchpoint; - t->to_remove_fork_catchpoint = inf_ptrace_remove_fork_catchpoint; - 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; -}