mirror of
https://sourceware.org/git/binutils-gdb.git
synced 2024-12-09 10:23:35 +08:00
268a13a5a3
This is the next patch in the ongoing series to move gdbsever to the top level. This patch just renames the "common" directory. The idea is to do this move in two parts: first rename the directory (this patch), then move the directory to the top. This approach makes the patches a bit more tractable. I chose the name "gdbsupport" for the directory. However, as this patch was largely written by sed, we could pick a new name without too much difficulty. Tested by the buildbot. gdb/ChangeLog 2019-07-09 Tom Tromey <tom@tromey.com> * contrib/ari/gdb_ari.sh: Change common to gdbsupport. * configure: Rebuild. * configure.ac: Change common to gdbsupport. * gdbsupport: Rename from common. * acinclude.m4: Change common to gdbsupport. * Makefile.in (CONFIG_SRC_SUBDIR, COMMON_SFILES) (HFILES_NO_SRCDIR, stamp-version, ALLDEPFILES): Change common to gdbsupport. * aarch64-tdep.c, ada-lang.c, ada-lang.h, agent.c, alloc.c, amd64-darwin-tdep.c, amd64-dicos-tdep.c, amd64-fbsd-nat.c, amd64-fbsd-tdep.c, amd64-linux-nat.c, amd64-linux-tdep.c, amd64-nbsd-tdep.c, amd64-obsd-tdep.c, amd64-sol2-tdep.c, amd64-tdep.c, amd64-windows-tdep.c, arch-utils.c, arch/aarch64-insn.c, arch/aarch64.c, arch/aarch64.h, arch/amd64.c, arch/amd64.h, arch/arm-get-next-pcs.c, arch/arm-linux.c, arch/arm.c, arch/i386.c, arch/i386.h, arch/ppc-linux-common.c, arch/riscv.c, arch/riscv.h, arch/tic6x.c, arm-tdep.c, auto-load.c, auxv.c, ax-gdb.c, ax-general.c, ax.h, breakpoint.c, breakpoint.h, btrace.c, btrace.h, build-id.c, build-id.h, c-lang.h, charset.c, charset.h, cli/cli-cmds.c, cli/cli-cmds.h, cli/cli-decode.c, cli/cli-dump.c, cli/cli-option.h, cli/cli-script.c, coff-pe-read.c, command.h, compile/compile-c-support.c, compile/compile-c.h, compile/compile-cplus-symbols.c, compile/compile-cplus-types.c, compile/compile-cplus.h, compile/compile-loc2c.c, compile/compile.c, completer.c, completer.h, contrib/ari/gdb_ari.sh, corefile.c, corelow.c, cp-support.c, cp-support.h, cp-valprint.c, csky-tdep.c, ctf.c, darwin-nat.c, debug.c, defs.h, disasm-selftests.c, disasm.c, disasm.h, dtrace-probe.c, dwarf-index-cache.c, dwarf-index-cache.h, dwarf-index-write.c, dwarf2-frame.c, dwarf2expr.c, dwarf2loc.c, dwarf2read.c, event-loop.c, event-top.c, exceptions.c, exec.c, extension.h, fbsd-nat.c, features/aarch64-core.c, features/aarch64-fpu.c, features/aarch64-pauth.c, features/aarch64-sve.c, features/i386/32bit-avx.c, features/i386/32bit-avx512.c, features/i386/32bit-core.c, features/i386/32bit-linux.c, features/i386/32bit-mpx.c, features/i386/32bit-pkeys.c, features/i386/32bit-segments.c, features/i386/32bit-sse.c, features/i386/64bit-avx.c, features/i386/64bit-avx512.c, features/i386/64bit-core.c, features/i386/64bit-linux.c, features/i386/64bit-mpx.c, features/i386/64bit-pkeys.c, features/i386/64bit-segments.c, features/i386/64bit-sse.c, features/i386/x32-core.c, features/riscv/32bit-cpu.c, features/riscv/32bit-csr.c, features/riscv/32bit-fpu.c, features/riscv/64bit-cpu.c, features/riscv/64bit-csr.c, features/riscv/64bit-fpu.c, features/tic6x-c6xp.c, features/tic6x-core.c, features/tic6x-gp.c, filename-seen-cache.h, findcmd.c, findvar.c, fork-child.c, gcore.c, gdb_bfd.c, gdb_bfd.h, gdb_proc_service.h, gdb_regex.c, gdb_select.h, gdb_usleep.c, gdbarch-selftests.c, gdbthread.h, gdbtypes.h, gnu-nat.c, go32-nat.c, guile/guile.c, guile/scm-ports.c, guile/scm-safe-call.c, guile/scm-type.c, i386-fbsd-nat.c, i386-fbsd-tdep.c, i386-go32-tdep.c, i386-linux-nat.c, i386-linux-tdep.c, i386-tdep.c, i387-tdep.c, ia64-libunwind-tdep.c, ia64-linux-nat.c, inf-child.c, inf-ptrace.c, infcall.c, infcall.h, infcmd.c, inferior-iter.h, inferior.c, inferior.h, inflow.c, inflow.h, infrun.c, infrun.h, inline-frame.c, language.h, linespec.c, linux-fork.c, linux-nat.c, linux-tdep.c, linux-thread-db.c, location.c, machoread.c, macrotab.h, main.c, maint.c, maint.h, memattr.c, memrange.h, mi/mi-cmd-break.h, mi/mi-cmd-env.c, mi/mi-cmd-stack.c, mi/mi-cmd-var.c, mi/mi-interp.c, mi/mi-main.c, mi/mi-parse.h, minsyms.c, mips-linux-tdep.c, namespace.h, nat/aarch64-linux-hw-point.c, nat/aarch64-linux-hw-point.h, nat/aarch64-linux.c, nat/aarch64-sve-linux-ptrace.c, nat/amd64-linux-siginfo.c, nat/fork-inferior.c, nat/linux-btrace.c, nat/linux-btrace.h, nat/linux-namespaces.c, nat/linux-nat.h, nat/linux-osdata.c, nat/linux-personality.c, nat/linux-procfs.c, nat/linux-ptrace.c, nat/linux-ptrace.h, nat/linux-waitpid.c, nat/mips-linux-watch.c, nat/mips-linux-watch.h, nat/ppc-linux.c, nat/x86-dregs.c, nat/x86-dregs.h, nat/x86-linux-dregs.c, nat/x86-linux.c, nto-procfs.c, nto-tdep.c, objfile-flags.h, objfiles.c, objfiles.h, obsd-nat.c, observable.h, osdata.c, p-valprint.c, parse.c, parser-defs.h, ppc-linux-nat.c, printcmd.c, probe.c, proc-api.c, procfs.c, producer.c, progspace.h, psymtab.h, python/py-framefilter.c, python/py-inferior.c, python/py-ref.h, python/py-type.c, python/python.c, record-btrace.c, record-full.c, record.c, record.h, regcache-dump.c, regcache.c, regcache.h, remote-fileio.c, remote-fileio.h, remote-sim.c, remote.c, riscv-tdep.c, rs6000-aix-tdep.c, rust-exp.y, s12z-tdep.c, selftest-arch.c, ser-base.c, ser-event.c, ser-pipe.c, ser-tcp.c, ser-unix.c, skip.c, solib-aix.c, solib-target.c, solib.c, source-cache.c, source.c, source.h, sparc-nat.c, spu-linux-nat.c, stack.c, stap-probe.c, symfile-add-flags.h, symfile.c, symfile.h, symtab.c, symtab.h, target-descriptions.c, target-descriptions.h, target-memory.c, target.c, target.h, target/waitstatus.c, target/waitstatus.h, thread-iter.h, thread.c, tilegx-tdep.c, top.c, top.h, tracefile-tfile.c, tracefile.c, tracepoint.c, tracepoint.h, tui/tui-io.c, ui-file.c, ui-out.h, unittests/array-view-selftests.c, unittests/child-path-selftests.c, unittests/cli-utils-selftests.c, unittests/common-utils-selftests.c, unittests/copy_bitwise-selftests.c, unittests/environ-selftests.c, unittests/format_pieces-selftests.c, unittests/function-view-selftests.c, unittests/lookup_name_info-selftests.c, unittests/memory-map-selftests.c, unittests/memrange-selftests.c, unittests/mkdir-recursive-selftests.c, unittests/observable-selftests.c, unittests/offset-type-selftests.c, unittests/optional-selftests.c, unittests/parse-connection-spec-selftests.c, unittests/ptid-selftests.c, unittests/rsp-low-selftests.c, unittests/scoped_fd-selftests.c, unittests/scoped_mmap-selftests.c, unittests/scoped_restore-selftests.c, unittests/string_view-selftests.c, unittests/style-selftests.c, unittests/tracepoint-selftests.c, unittests/unpack-selftests.c, unittests/utils-selftests.c, unittests/xml-utils-selftests.c, utils.c, utils.h, valarith.c, valops.c, valprint.c, value.c, value.h, varobj.c, varobj.h, windows-nat.c, x86-linux-nat.c, xml-support.c, xml-support.h, xml-tdesc.h, xstormy16-tdep.c, xtensa-linux-nat.c, dwarf2read.h: Change common to gdbsupport. gdb/gdbserver/ChangeLog 2019-07-09 Tom Tromey <tom@tromey.com> * configure: Rebuild. * configure.ac: Change common to gdbsupport. * acinclude.m4: Change common to gdbsupport. * Makefile.in (SFILES, OBS, GDBREPLAY_OBS, IPA_OBJS) (version-generated.c, gdbsupport/%-ipa.o, gdbsupport/%.o): Change common to gdbsupport. * ax.c, event-loop.c, fork-child.c, gdb_proc_service.h, gdbreplay.c, gdbthread.h, hostio-errno.c, hostio.c, i387-fp.c, inferiors.c, inferiors.h, linux-aarch64-tdesc-selftest.c, linux-amd64-ipa.c, linux-i386-ipa.c, linux-low.c, linux-tic6x-low.c, linux-x86-low.c, linux-x86-tdesc-selftest.c, linux-x86-tdesc.c, lynx-i386-low.c, lynx-low.c, mem-break.h, nto-x86-low.c, regcache.c, regcache.h, remote-utils.c, server.c, server.h, spu-low.c, symbol.c, target.h, tdesc.c, tdesc.h, thread-db.c, tracepoint.c, win32-i386-low.c, win32-low.c: Change common to gdbsupport.
671 lines
18 KiB
C
671 lines
18 KiB
C
/* Low-level child interface to ptrace.
|
||
|
||
Copyright (C) 1988-2019 Free Software Foundation, Inc.
|
||
|
||
This file is part of GDB.
|
||
|
||
This program is free software; you can redistribute it and/or modify
|
||
it under the terms of the GNU General Public License as published by
|
||
the Free Software Foundation; either version 3 of the License, or
|
||
(at your option) any later version.
|
||
|
||
This program is distributed in the hope that it will be useful,
|
||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||
GNU General Public License for more details.
|
||
|
||
You should have received a copy of the GNU General Public License
|
||
along with this program. If not, see <http://www.gnu.org/licenses/>. */
|
||
|
||
#include "defs.h"
|
||
#include "command.h"
|
||
#include "inferior.h"
|
||
#include "inflow.h"
|
||
#include "terminal.h"
|
||
#include "gdbcore.h"
|
||
#include "regcache.h"
|
||
#include "nat/gdb_ptrace.h"
|
||
#include "gdbsupport/gdb_wait.h"
|
||
#include <signal.h>
|
||
|
||
#include "inf-ptrace.h"
|
||
#include "inf-child.h"
|
||
#include "gdbthread.h"
|
||
#include "nat/fork-inferior.h"
|
||
#include "utils.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<struct target_ops, target_unpusher> 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. */
|
||
|
||
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 = tp->pending_follow.value.related_pid.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;
|
||
}
|
||
|
||
int
|
||
inf_ptrace_target::insert_fork_catchpoint (int pid)
|
||
{
|
||
return 0;
|
||
}
|
||
|
||
int
|
||
inf_ptrace_target::remove_fork_catchpoint (int pid)
|
||
{
|
||
return 0;
|
||
}
|
||
|
||
#endif /* PT_GET_PROCESS_STATE */
|
||
|
||
|
||
/* Prepare to be traced. */
|
||
|
||
static void
|
||
inf_ptrace_me (void)
|
||
{
|
||
/* "Trace me, Dr. Memory!" */
|
||
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
|
||
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. */
|
||
|
||
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 (this);
|
||
|
||
target_unpush_up unpusher;
|
||
if (! ops_already_pushed)
|
||
{
|
||
/* Clear possible core file with its process_stratum. */
|
||
push_target (this);
|
||
unpusher.reset (this);
|
||
}
|
||
|
||
pid = fork_inferior (exec_file, allargs, env, inf_ptrace_me, NULL,
|
||
NULL, NULL, NULL);
|
||
|
||
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);
|
||
|
||
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 (ptid);
|
||
}
|
||
|
||
#ifdef PT_GET_PROCESS_STATE
|
||
|
||
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, 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. */
|
||
|
||
void
|
||
inf_ptrace_target::mourn_inferior ()
|
||
{
|
||
int status;
|
||
|
||
/* Wait just one more time to collect the inferior's exit status.
|
||
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 (inferior_ptid.pid (), &status, 0);
|
||
|
||
inf_child_target::mourn_inferior ();
|
||
}
|
||
|
||
/* Attach to the process specified by ARGS. If FROM_TTY is non-zero,
|
||
be chatty about it. */
|
||
|
||
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 (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 (this);
|
||
unpusher.reset (this);
|
||
}
|
||
|
||
if (from_tty)
|
||
{
|
||
exec_file = get_exec_file (0);
|
||
|
||
if (exec_file)
|
||
printf_unfiltered (_("Attaching to program: %s, %s\n"), exec_file,
|
||
target_pid_to_str (ptid_t (pid)).c_str ());
|
||
else
|
||
printf_unfiltered (_("Attaching to %s\n"),
|
||
target_pid_to_str (ptid_t (pid)).c_str ());
|
||
}
|
||
|
||
#ifdef PT_ATTACH
|
||
errno = 0;
|
||
ptrace (PT_ATTACH, pid, (PTRACE_TYPE_ARG3)0, 0);
|
||
if (errno != 0)
|
||
perror_with_name (("ptrace"));
|
||
#else
|
||
error (_("This system does not support attaching to a process"));
|
||
#endif
|
||
|
||
inf = current_inferior ();
|
||
inferior_appeared (inf, pid);
|
||
inf->attach_flag = 1;
|
||
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);
|
||
/* Don't consider the thread stopped until we've processed its
|
||
initial SIGSTOP stop. */
|
||
set_executing (thr->ptid, true);
|
||
|
||
unpusher.release ();
|
||
}
|
||
|
||
#ifdef PT_GET_PROCESS_STATE
|
||
|
||
void
|
||
inf_ptrace_target::post_attach (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. */
|
||
|
||
void
|
||
inf_ptrace_target::detach (inferior *inf, int from_tty)
|
||
{
|
||
pid_t pid = inferior_ptid.pid ();
|
||
|
||
target_announce_detach (from_tty);
|
||
|
||
#ifdef PT_DETACH
|
||
/* We'd better not have left any breakpoints in the program or it'll
|
||
die when it hits one. Also 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, 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 (inf);
|
||
|
||
maybe_unpush_target ();
|
||
}
|
||
|
||
/* Kill the inferior. */
|
||
|
||
void
|
||
inf_ptrace_target::kill ()
|
||
{
|
||
pid_t pid = inferior_ptid.pid ();
|
||
int status;
|
||
|
||
if (pid == 0)
|
||
return;
|
||
|
||
ptrace (PT_KILL, pid, (PTRACE_TYPE_ARG3)0, 0);
|
||
waitpid (pid, &status, 0);
|
||
|
||
target_mourn_inferior (inferior_ptid);
|
||
}
|
||
|
||
/* Return which PID to pass to ptrace in order to observe/control the
|
||
tracee identified by PTID. */
|
||
|
||
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.lwp ();
|
||
if (pid == 0)
|
||
pid = ptid.pid ();
|
||
return pid;
|
||
}
|
||
|
||
/* 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. */
|
||
|
||
void
|
||
inf_ptrace_target::resume (ptid_t ptid, int step, enum gdb_signal signal)
|
||
{
|
||
pid_t pid;
|
||
int request;
|
||
|
||
if (minus_one_ptid == ptid)
|
||
/* Resume all threads. Traditionally ptrace() only supports
|
||
single-threaded processes, so simply resume the inferior. */
|
||
pid = inferior_ptid.pid ();
|
||
else
|
||
pid = get_ptrace_pid (ptid);
|
||
|
||
if (catch_syscall_enabled () > 0)
|
||
request = PT_SYSCALL;
|
||
else
|
||
request = PT_CONTINUE;
|
||
|
||
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;
|
||
}
|
||
|
||
/* 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, gdb_signal_to_host (signal));
|
||
if (errno != 0)
|
||
perror_with_name (("ptrace"));
|
||
}
|
||
|
||
/* 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. */
|
||
|
||
ptid_t
|
||
inf_ptrace_target::wait (ptid_t ptid, struct target_waitstatus *ourstatus,
|
||
int options)
|
||
{
|
||
pid_t pid;
|
||
int status, save_errno;
|
||
|
||
do
|
||
{
|
||
set_sigint_trap ();
|
||
|
||
do
|
||
{
|
||
pid = waitpid (ptid.pid (), &status, 0);
|
||
save_errno = errno;
|
||
}
|
||
while (pid == -1 && errno == EINTR);
|
||
|
||
clear_sigint_trap ();
|
||
|
||
if (pid == -1)
|
||
{
|
||
fprintf_unfiltered (gdb_stderr,
|
||
_("Child process unexpectedly missing: %s.\n"),
|
||
safe_strerror (save_errno));
|
||
|
||
/* Claim it exited with unknown signal. */
|
||
ourstatus->kind = TARGET_WAITKIND_SIGNALLED;
|
||
ourstatus->value.sig = GDB_SIGNAL_UNKNOWN;
|
||
return inferior_ptid;
|
||
}
|
||
|
||
/* Ignore terminated detached child processes. */
|
||
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 = 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);
|
||
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 == inferior_ptid.pid ())
|
||
{
|
||
ourstatus->value.related_pid = ptid_t (pe.pe_other_pid);
|
||
return ptid_t (fpid);
|
||
}
|
||
|
||
return ptid_t (pid);
|
||
}
|
||
}
|
||
#endif
|
||
|
||
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 (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. */
|
||
|
||
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);
|
||
|
||
switch (object)
|
||
{
|
||
case TARGET_OBJECT_MEMORY:
|
||
#ifdef PT_IO
|
||
/* OpenBSD 3.1, NetBSD 1.6 and FreeBSD 5.0 have a new PT_IO
|
||
request that promises to be much more efficient in reading
|
||
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. However, on OpenBSD 3.9 and
|
||
later, PIOD_WRITE_D doesn't allow changing memory that's
|
||
mapped read-only. Since most code segments will be
|
||
read-only, using PIOD_WRITE_D will prevent us from
|
||
inserting breakpoints, so we use PIOD_WRITE_I instead. */
|
||
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, pid, (caddr_t)&piod, 0) == 0)
|
||
{
|
||
/* Return the actual number of bytes read or written. */
|
||
*xfered_len = piod.piod_len;
|
||
return (piod.piod_len == 0) ? TARGET_XFER_EOF : TARGET_XFER_OK;
|
||
}
|
||
/* If the PT_IO request is somehow not supported, fallback on
|
||
using PT_WRITE_D/PT_READ_D. Otherwise we will return zero
|
||
to indicate failure. */
|
||
if (errno != EINVAL)
|
||
return TARGET_XFER_EOF;
|
||
}
|
||
#endif
|
||
*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;
|
||
|
||
case TARGET_OBJECT_AUXV:
|
||
#if defined (PT_IO) && defined (PIOD_READ_AUXV)
|
||
/* OpenBSD 4.5 has a new PIOD_READ_AUXV operation for the PT_IO
|
||
request that allows us to read the auxilliary vector. Other
|
||
BSD's may follow if they feel the need to support PIE. */
|
||
{
|
||
struct ptrace_io_desc piod;
|
||
|
||
if (writebuf)
|
||
return TARGET_XFER_E_IO;
|
||
piod.piod_op = PIOD_READ_AUXV;
|
||
piod.piod_addr = readbuf;
|
||
piod.piod_offs = (void *) (long) offset;
|
||
piod.piod_len = len;
|
||
|
||
errno = 0;
|
||
if (ptrace (PT_IO, pid, (caddr_t)&piod, 0) == 0)
|
||
{
|
||
/* Return the actual number of bytes read or written. */
|
||
*xfered_len = piod.piod_len;
|
||
return (piod.piod_len == 0) ? TARGET_XFER_EOF : TARGET_XFER_OK;
|
||
}
|
||
}
|
||
#endif
|
||
return TARGET_XFER_E_IO;
|
||
|
||
case TARGET_OBJECT_WCOOKIE:
|
||
return TARGET_XFER_E_IO;
|
||
|
||
default:
|
||
return TARGET_XFER_E_IO;
|
||
}
|
||
}
|
||
|
||
/* Return non-zero if the thread specified by PTID is alive. */
|
||
|
||
bool
|
||
inf_ptrace_target::thread_alive (ptid_t ptid)
|
||
{
|
||
/* ??? Is kill the right way to do this? */
|
||
return (::kill (ptid.pid (), 0) != -1);
|
||
}
|
||
|
||
/* Print status information about what we're accessing. */
|
||
|
||
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).c_str ());
|
||
}
|
||
|
||
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. */
|
||
|
||
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;
|
||
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
|
||
|