X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=gdb%2Finf-ptrace.c;h=a83ffcc87989b90416c4df58378dc26f883d3136;hb=a89febbd83b48439bc447d0b1699e30a70f56936;hp=1fd41bf4ed784c0508a755789fdd6707a560b440;hpb=6798487f5bc66ab9c34ad81fa28ba25d32a00bd9;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/inf-ptrace.c b/gdb/inf-ptrace.c index 1fd41bf4ed..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-2018 Free Software Foundation, Inc. + Copyright (C) 1988-2020 Free Software Foundation, Inc. This file is part of GDB. @@ -25,7 +25,7 @@ #include "gdbcore.h" #include "regcache.h" #include "nat/gdb_ptrace.h" -#include "gdb_wait.h" +#include "gdbsupport/gdb_wait.h" #include #include "inf-ptrace.h" @@ -33,9 +33,22 @@ #include "gdbthread.h" #include "nat/fork-inferior.h" #include "utils.h" +#include "gdbarch.h" +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 +} + /* A unique_ptr helper to unpush a target. */ struct target_unpusher @@ -52,43 +65,9 @@ typedef std::unique_ptr target_unpush_up; -#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) -{ - if (!follow_child) - { - struct thread_info *tp = inferior_thread (); - pid_t child_pid = ptid_get_pid (tp->pending_follow.value.related_pid); - - /* Breakpoints have already been detached from the child by - infrun.c. */ - - if (ptrace (PT_DETACH, child_pid, (PTRACE_TYPE_ARG3)1, 0) == -1) - perror_with_name (("ptrace")); - } - - return 0; -} - -static int -inf_ptrace_insert_fork_catchpoint (struct target_ops *self, int pid) -{ - return 0; -} +inf_ptrace_target::~inf_ptrace_target () +{} -static int -inf_ptrace_remove_fork_catchpoint (struct target_ops *self, int pid) -{ - return 0; -} - -#endif /* PT_GET_PROCESS_STATE */ /* Prepare to be traced. */ @@ -106,34 +85,34 @@ 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, - const char *exec_file, const std::string &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) { 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); + 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); - unpusher.reset (ops); + push_target (this); + unpusher.reset (this); } pid = fork_inferior (exec_file, allargs, env, inf_ptrace_me, NULL, NULL, NULL, NULL); - ptid = pid_to_ptid (pid); + 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 (ptid); + add_thread_silent (this, ptid); unpusher.release (); @@ -144,27 +123,10 @@ inf_ptrace_create_inferior (struct target_ops *ops, target_post_startup_inferior (ptid); } -#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")); -} - -#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; @@ -172,24 +134,23 @@ 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); + int ops_already_pushed = target_is_pushed (this); pid = parse_pid_to_attach (args); @@ -201,22 +162,20 @@ inf_ptrace_attach (struct target_ops *ops, const char *args, int from_tty) { /* target_pid_to_str already uses the target. Also clear possible core file with its process_stratum. */ - push_target (ops); - unpusher.reset (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 @@ -231,41 +190,24 @@ 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. */ - thread_info *thr = 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 (thr->ptid, true); + set_executing (this, thr->ptid, true); unpusher.release (); } -#ifdef PT_GET_PROCESS_STATE - -static void -inf_ptrace_post_attach (struct target_ops *self, int 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, pid, - (PTRACE_TYPE_ARG3)&pe, sizeof pe) == -1) - perror_with_name (("ptrace")); -} - -#endif - /* Detach from the inferior. If FROM_TTY is non-zero, be chatty about it. */ -static void -inf_ptrace_detach (struct target_ops *ops, inferior *inf, int from_tty) +void +inf_ptrace_target::detach (inferior *inf, int from_tty) { - pid_t pid = ptid_get_pid (inferior_ptid); + pid_t pid = inferior_ptid.pid (); target_announce_detach (from_tty); @@ -282,26 +224,26 @@ inf_ptrace_detach (struct target_ops *ops, inferior *inf, int from_tty) error (_("This system does not support detaching from a process")); #endif - inf_ptrace_detach_success (ops, inf); + detach_success (inf); } /* See inf-ptrace.h. */ void -inf_ptrace_detach_success (struct target_ops *ops, inferior *inf) +inf_ptrace_target::detach_success (inferior *inf) { inferior_ptid = null_ptid; 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) @@ -313,8 +255,9 @@ inf_ptrace_kill (struct target_ops *ops) target_mourn_inferior (inferior_ptid); } -/* Return which PID to pass to ptrace in order to observe/control the - tracee identified by PTID. */ +#ifndef __NetBSD__ + +/* See inf-ptrace.h. */ pid_t get_ptrace_pid (ptid_t ptid) @@ -323,29 +266,26 @@ get_ptrace_pid (ptid_t ptid) /* 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; } +#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; - int request; + PTRACE_TYPE_ARG1 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); - else - pid = get_ptrace_pid (ptid); + ptid = ptid_t (inferior_ptid.pid ()); if (catch_syscall_enabled () > 0) request = PT_SYSCALL; @@ -355,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; } @@ -366,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")); } @@ -375,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; @@ -388,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); @@ -408,51 +348,13 @@ 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)) - { - ptrace_state_t pe; - pid_t fpid; - - if (ptrace (PT_GET_PROCESS_STATE, pid, - (PTRACE_TYPE_ARG3)&pe, sizeof pe) == -1) - perror_with_name (("ptrace")); - - switch (pe.pe_report_event) - { - 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)) - { - ourstatus->value.related_pid = pid_to_ptid (pe.pe_other_pid); - return pid_to_ptid (fpid); - } - - return pid_to_ptid (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 @@ -461,7 +363,7 @@ inf_ptrace_wait (struct target_ops *ops, be non-null. Return the number of transferred bytes. */ static ULONGEST -inf_ptrace_peek_poke (pid_t pid, gdb_byte *readbuf, +inf_ptrace_peek_poke (ptid_t ptid, gdb_byte *readbuf, const gdb_byte *writebuf, ULONGEST addr, ULONGEST len) { @@ -492,8 +394,8 @@ inf_ptrace_peek_poke (pid_t pid, gdb_byte *readbuf, if (readbuf != NULL || chunk < sizeof (PTRACE_TYPE_RET)) { errno = 0; - buf.word = ptrace (PT_READ_I, pid, - (PTRACE_TYPE_ARG3)(uintptr_t) addr, 0); + buf.word = gdb_ptrace (PT_READ_I, ptid, + (PTRACE_TYPE_ARG3)(uintptr_t) addr, 0); if (errno != 0) break; if (readbuf != NULL) @@ -503,15 +405,15 @@ inf_ptrace_peek_poke (pid_t pid, gdb_byte *readbuf, { memcpy (buf.byte + skip, writebuf + n, chunk); errno = 0; - ptrace (PT_WRITE_D, pid, (PTRACE_TYPE_ARG3)(uintptr_t) addr, + gdb_ptrace (PT_WRITE_D, ptid, (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); + gdb_ptrace (PT_WRITE_I, ptid, (PTRACE_TYPE_ARG3)(uintptr_t) addr, + buf.word); if (errno != 0) break; } @@ -523,13 +425,13 @@ inf_ptrace_peek_poke (pid_t pid, gdb_byte *readbuf, /* 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 = get_ptrace_pid (inferior_ptid); + ptid_t ptid = inferior_ptid; switch (object) { @@ -553,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; @@ -566,7 +468,7 @@ inf_ptrace_xfer_partial (struct target_ops *ops, enum target_object object, return TARGET_XFER_EOF; } #endif - *xfered_len = inf_ptrace_peek_poke (pid, readbuf, writebuf, + *xfered_len = inf_ptrace_peek_poke (ptid, readbuf, writebuf, offset, len); return *xfered_len != 0 ? TARGET_XFER_OK : TARGET_XFER_EOF; @@ -589,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; @@ -609,96 +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 const 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_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_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; -} -