/* 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.
#include "gdbcore.h"
#include "regcache.h"
#include "nat/gdb_ptrace.h"
-#include "gdb_wait.h"
+#include "gdbsupport/gdb_wait.h"
#include <signal.h>
#include "inf-ptrace.h"
#include "gdbthread.h"
#include "nat/fork-inferior.h"
#include "utils.h"
+#include "gdbarch.h"
\f
+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
/* Target hook for follow_fork. On entry and at return inferior_ptid is
the ptid of the followed inferior. */
-int
-inf_ptrace_target::follow_fork (int follow_child, int detach_fork)
+bool
+inf_ptrace_target::follow_fork (bool follow_child, bool 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. */
perror_with_name (("ptrace"));
}
- return 0;
+ return false;
}
int
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 ();
/* 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"));
}
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_target::mourn_inferior ();
}
void
inf_ptrace_target::attach (const char *args, int from_tty)
{
- char *exec_file;
pid_t pid;
struct inferior *inf;
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
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 ();
}
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);
void
inf_ptrace_target::kill ()
{
- pid_t pid = ptid_get_pid (inferior_ptid);
+ pid_t pid = inferior_ptid.pid ();
int status;
if (pid == 0)
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)
/* 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
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;
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;
}
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"));
}
do
{
- pid = waitpid (ptid_get_pid (ptid), &status, 0);
+ pid = waitpid (ptid.pid (), &status, 0);
save_errno = errno;
}
while (pid == -1 && errno == EINTR);
}
/* 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);
{
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);
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
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)
{
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)
{
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;
}
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)
{
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;
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;
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;
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. */
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 ());
}
-const char *
+std::string
inf_ptrace_target::pid_to_str (ptid_t ptid)
{
return normal_pid_to_str (ptid);
projects / deliverable / binutils-gdb.git / blobdiff