mirror of
https://sourceware.org/git/binutils-gdb.git
synced 2024-12-21 04:42:53 +08:00
9c02b52532
Running the testsuite with a series that reimplements user-visible
all-stop behavior on top of a target running in non-stop mode revealed
problems related to event starvation avoidance.
For example, I see
gdb.threads/signal-while-stepping-over-bp-other-thread.exp failing.
What happens is that GDB core never gets to see the signal event. It
ends up processing the events for the same threads over an over,
because Linux's waitpid(-1, ...) returns that first task in the task
list that has an event, starving threads on the tail of the task list.
So I wrote a non-stop mode test originally inspired by
signal-while-stepping-over-bp-other-thread.exp, to stress this
independently of all-stop on top of non-stop. Fixing it required the
changes described below. The test will be added in a following
commit.
1) linux-nat.c has code in place that picks an event LWP at random out
of all that have had events. This is because on the kernel side,
"waitpid(-1, ...)" just walks the task list linearly looking for the
first that had an event. But, this code is currently only used in
all-stop mode. So with a multi-threaded program that has multiple
events triggering debug events in parallel, GDB ends up starving some
threads.
To make the event randomization work in non-stop mode too, the patch
makes us pull out all the already pending events on the kernel side,
with waitpid, before deciding which LWP to report to the core.
There's some code in linux_wait that takes care of leaving events
pending if they were for LWPs the caller is not interested in. The
patch moves that to linux_nat_filter_event, so that we only have one
place that leaves events pending. With that in place, conceptually,
the flow is simpler and more normalized:
#1 - walk the LWP list looking for an LWP with a pending event to report.
#2 - if no pending event, pull events out of the kernel, and store
them in the LWP structures as pending.
#3- goto #1.
2) Then, currently the event randomization code only considers SIGTRAP
(or trap-like) events. That means that if e.g., have have multiple
threads stepping in parallel that hit a breakpoint that needs stepping
over, and one gets a signal, the signal may end up never getting
processed, because GDB will always be giving priority to the SIGTRAPs.
The patch fixes this by making the randomization code consider all
kinds of pending events.
3) If multiple threads hit a breakpoint, we report one of those, and
"cancel" the others. Cancelling means decrementing the PC, and
discarding the event. If the next time the LWP is resumed the
breakpoint is still installed, the LWP should hit it again, and we'll
report the hit then. The problem I found is that this delays threads
from advancing too much, with the kernel potentially ending up
scheduling the same threads over and over, and others not advancing.
So the patch switches away from cancelling the breakpoints, and
instead remembering that the LWP had stopped for a breakpoint. If on
resume the breakpoint is still installed, we report it. If it's no
longer installed, we discard the pending event then. This is actually
how GDBserver used to handle this before d50171e4
(Teach linux
gdbserver to step-over-breakpoints), but with the difference that back
then we'd delay adjusting the PC until resuming, which made it so that
"info threads" could wrongly see threads with unadjusted PCs.
gdb/
2015-01-09 Pedro Alves <palves@redhat.com>
* breakpoint.c (hardware_breakpoint_inserted_here_p): New
function.
* breakpoint.h (hardware_breakpoint_inserted_here_p): New
declaration.
* linux-nat.c (linux_nat_status_is_event): Move higher up in file.
(linux_resume_one_lwp): Store the thread's PC. Adjust to clear
stop_reason.
(check_stopped_by_watchpoint): New function.
(save_sigtrap): Reimplement.
(linux_nat_stopped_by_watchpoint): Adjust.
(linux_nat_lp_status_is_event): Delete.
(stop_wait_callback): Only call save_sigtrap after storing the
pending status.
(status_callback): If the thread had been stopped for a breakpoint
that has since been removed, discard the event and resume the LWP.
(count_events_callback, select_event_lwp_callback): Use
lwp_status_pending_p instead of linux_nat_lp_status_is_event.
(cancel_breakpoint): Rename to ...
(check_stopped_by_breakpoint): ... this. Record whether the LWP
stopped for a software breakpoint or hardware breakpoint.
(select_event_lwp): Only give preference to the stepping LWP in
all-stop mode. Adjust comments.
(stop_and_resume_callback): Remove references to new_pending_p.
(linux_nat_filter_event): Likewise. Leave exit events of the
leader thread pending here. Handle signal short circuiting here.
Only call save_sigtrap after storing the pending waitstatus.
(linux_nat_wait_1): Remove 'retry' label. Remove references to
new_pending. Don't handle leaving events the caller is not
interested in pending here, nor handle signal short-circuiting
here. Also give equal priority to all LWPs that have had events
in non-stop mode. If reporting a software breakpoint event,
unadjust the LWP's PC.
* linux-nat.h (enum lwp_stop_reason): New.
(struct lwp_info) <stop_pc>: New field.
(struct lwp_info) <stopped_by_watchpoint>: Delete field.
(struct lwp_info) <stop_reason>: New field.
* x86-linux-nat.c (x86_linux_prepare_to_resume): Adjust.
568 lines
15 KiB
C
568 lines
15 KiB
C
/* Native-dependent code for GNU/Linux x86 (i386 and x86-64).
|
||
|
||
Copyright (C) 1999-2015 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 "inferior.h"
|
||
#include "elf/common.h"
|
||
#include "gdb_proc_service.h"
|
||
#include <sys/ptrace.h>
|
||
#include <sys/user.h>
|
||
#include <sys/procfs.h>
|
||
#include <sys/uio.h>
|
||
|
||
#include "x86-nat.h"
|
||
#include "linux-nat.h"
|
||
#ifndef __x86_64__
|
||
#include "i386-linux-nat.h"
|
||
#endif
|
||
#include "x86-linux-nat.h"
|
||
#include "i386-linux-tdep.h"
|
||
#ifdef __x86_64__
|
||
#include "amd64-linux-tdep.h"
|
||
#endif
|
||
#include "x86-xstate.h"
|
||
#include "nat/linux-btrace.h"
|
||
|
||
/* Per-thread arch-specific data we want to keep. */
|
||
|
||
struct arch_lwp_info
|
||
{
|
||
/* Non-zero if our copy differs from what's recorded in the thread. */
|
||
int debug_registers_changed;
|
||
};
|
||
|
||
/* Does the current host support PTRACE_GETREGSET? */
|
||
int have_ptrace_getregset = -1;
|
||
|
||
|
||
/* Support for debug registers. */
|
||
|
||
/* Get debug register REGNUM value from only the one LWP of PTID. */
|
||
|
||
static unsigned long
|
||
x86_linux_dr_get (ptid_t ptid, int regnum)
|
||
{
|
||
int tid;
|
||
unsigned long value;
|
||
|
||
gdb_assert (ptid_lwp_p (ptid));
|
||
tid = ptid_get_lwp (ptid);
|
||
|
||
errno = 0;
|
||
value = ptrace (PTRACE_PEEKUSER, tid,
|
||
offsetof (struct user, u_debugreg[regnum]), 0);
|
||
if (errno != 0)
|
||
perror_with_name (_("Couldn't read debug register"));
|
||
|
||
return value;
|
||
}
|
||
|
||
/* Set debug register REGNUM to VALUE in only the one LWP of PTID. */
|
||
|
||
static void
|
||
x86_linux_dr_set (ptid_t ptid, int regnum, unsigned long value)
|
||
{
|
||
int tid;
|
||
|
||
gdb_assert (ptid_lwp_p (ptid));
|
||
tid = ptid_get_lwp (ptid);
|
||
|
||
errno = 0;
|
||
ptrace (PTRACE_POKEUSER, tid,
|
||
offsetof (struct user, u_debugreg[regnum]), value);
|
||
if (errno != 0)
|
||
perror_with_name (_("Couldn't write debug register"));
|
||
}
|
||
|
||
/* Return the inferior's debug register REGNUM. */
|
||
|
||
static CORE_ADDR
|
||
x86_linux_dr_get_addr (int regnum)
|
||
{
|
||
/* DR6 and DR7 are retrieved with some other way. */
|
||
gdb_assert (DR_FIRSTADDR <= regnum && regnum <= DR_LASTADDR);
|
||
|
||
return x86_linux_dr_get (inferior_ptid, regnum);
|
||
}
|
||
|
||
/* Return the inferior's DR7 debug control register. */
|
||
|
||
static unsigned long
|
||
x86_linux_dr_get_control (void)
|
||
{
|
||
return x86_linux_dr_get (inferior_ptid, DR_CONTROL);
|
||
}
|
||
|
||
/* Get DR_STATUS from only the one LWP of INFERIOR_PTID. */
|
||
|
||
static unsigned long
|
||
x86_linux_dr_get_status (void)
|
||
{
|
||
return x86_linux_dr_get (inferior_ptid, DR_STATUS);
|
||
}
|
||
|
||
/* Callback for iterate_over_lwps. Update the debug registers of
|
||
LWP. */
|
||
|
||
static int
|
||
update_debug_registers_callback (struct lwp_info *lwp, void *arg)
|
||
{
|
||
if (lwp->arch_private == NULL)
|
||
lwp->arch_private = XCNEW (struct arch_lwp_info);
|
||
|
||
/* The actual update is done later just before resuming the lwp, we
|
||
just mark that the registers need updating. */
|
||
lwp->arch_private->debug_registers_changed = 1;
|
||
|
||
/* If the lwp isn't stopped, force it to momentarily pause, so we
|
||
can update its debug registers. */
|
||
if (!lwp->stopped)
|
||
linux_stop_lwp (lwp);
|
||
|
||
/* Continue the iteration. */
|
||
return 0;
|
||
}
|
||
|
||
/* Set DR_CONTROL to CONTROL in all LWPs of the current inferior. */
|
||
|
||
static void
|
||
x86_linux_dr_set_control (unsigned long control)
|
||
{
|
||
ptid_t pid_ptid = pid_to_ptid (ptid_get_pid (inferior_ptid));
|
||
|
||
iterate_over_lwps (pid_ptid, update_debug_registers_callback, NULL);
|
||
}
|
||
|
||
/* Set address REGNUM (zero based) to ADDR in all LWPs of the current
|
||
inferior. */
|
||
|
||
static void
|
||
x86_linux_dr_set_addr (int regnum, CORE_ADDR addr)
|
||
{
|
||
ptid_t pid_ptid = pid_to_ptid (ptid_get_pid (inferior_ptid));
|
||
|
||
gdb_assert (regnum >= 0 && regnum <= DR_LASTADDR - DR_FIRSTADDR);
|
||
|
||
iterate_over_lwps (pid_ptid, update_debug_registers_callback, NULL);
|
||
}
|
||
|
||
/* Called when resuming a thread.
|
||
If the debug regs have changed, update the thread's copies. */
|
||
|
||
static void
|
||
x86_linux_prepare_to_resume (struct lwp_info *lwp)
|
||
{
|
||
int clear_status = 0;
|
||
|
||
/* NULL means this is the main thread still going through the shell,
|
||
or, no watchpoint has been set yet. In that case, there's
|
||
nothing to do. */
|
||
if (lwp->arch_private == NULL)
|
||
return;
|
||
|
||
if (lwp->arch_private->debug_registers_changed)
|
||
{
|
||
struct x86_debug_reg_state *state
|
||
= x86_debug_reg_state (ptid_get_pid (lwp->ptid));
|
||
int i;
|
||
|
||
/* On Linux kernel before 2.6.33 commit
|
||
72f674d203cd230426437cdcf7dd6f681dad8b0d
|
||
if you enable a breakpoint by the DR_CONTROL bits you need to have
|
||
already written the corresponding DR_FIRSTADDR...DR_LASTADDR registers.
|
||
|
||
Ensure DR_CONTROL gets written as the very last register here. */
|
||
|
||
/* Clear DR_CONTROL first. In some cases, setting DR0-3 to a
|
||
value that doesn't match what is enabled in DR_CONTROL
|
||
results in EINVAL. */
|
||
x86_linux_dr_set (lwp->ptid, DR_CONTROL, 0);
|
||
|
||
ALL_DEBUG_ADDRESS_REGISTERS (i)
|
||
if (state->dr_ref_count[i] > 0)
|
||
{
|
||
x86_linux_dr_set (lwp->ptid, i, state->dr_mirror[i]);
|
||
|
||
/* If we're setting a watchpoint, any change the inferior
|
||
had done itself to the debug registers needs to be
|
||
discarded, otherwise, x86_stopped_data_address can get
|
||
confused. */
|
||
clear_status = 1;
|
||
}
|
||
|
||
/* If DR_CONTROL is supposed to be zero, we've already set it
|
||
above. */
|
||
if (state->dr_control_mirror != 0)
|
||
x86_linux_dr_set (lwp->ptid, DR_CONTROL, state->dr_control_mirror);
|
||
|
||
lwp->arch_private->debug_registers_changed = 0;
|
||
}
|
||
|
||
if (clear_status || lwp->stop_reason == LWP_STOPPED_BY_WATCHPOINT)
|
||
x86_linux_dr_set (lwp->ptid, DR_STATUS, 0);
|
||
}
|
||
|
||
static void
|
||
x86_linux_new_thread (struct lwp_info *lp)
|
||
{
|
||
struct arch_lwp_info *info = XCNEW (struct arch_lwp_info);
|
||
|
||
info->debug_registers_changed = 1;
|
||
|
||
lp->arch_private = info;
|
||
}
|
||
|
||
|
||
/* linux_nat_new_fork hook. */
|
||
|
||
static void
|
||
x86_linux_new_fork (struct lwp_info *parent, pid_t child_pid)
|
||
{
|
||
pid_t parent_pid;
|
||
struct x86_debug_reg_state *parent_state;
|
||
struct x86_debug_reg_state *child_state;
|
||
|
||
/* NULL means no watchpoint has ever been set in the parent. In
|
||
that case, there's nothing to do. */
|
||
if (parent->arch_private == NULL)
|
||
return;
|
||
|
||
/* Linux kernel before 2.6.33 commit
|
||
72f674d203cd230426437cdcf7dd6f681dad8b0d
|
||
will inherit hardware debug registers from parent
|
||
on fork/vfork/clone. Newer Linux kernels create such tasks with
|
||
zeroed debug registers.
|
||
|
||
GDB core assumes the child inherits the watchpoints/hw
|
||
breakpoints of the parent, and will remove them all from the
|
||
forked off process. Copy the debug registers mirrors into the
|
||
new process so that all breakpoints and watchpoints can be
|
||
removed together. The debug registers mirror will become zeroed
|
||
in the end before detaching the forked off process, thus making
|
||
this compatible with older Linux kernels too. */
|
||
|
||
parent_pid = ptid_get_pid (parent->ptid);
|
||
parent_state = x86_debug_reg_state (parent_pid);
|
||
child_state = x86_debug_reg_state (child_pid);
|
||
*child_state = *parent_state;
|
||
}
|
||
|
||
|
||
static void (*super_post_startup_inferior) (struct target_ops *self,
|
||
ptid_t ptid);
|
||
|
||
static void
|
||
x86_linux_child_post_startup_inferior (struct target_ops *self, ptid_t ptid)
|
||
{
|
||
x86_cleanup_dregs ();
|
||
super_post_startup_inferior (self, ptid);
|
||
}
|
||
|
||
#ifdef __x86_64__
|
||
/* Value of CS segment register:
|
||
64bit process: 0x33
|
||
32bit process: 0x23 */
|
||
#define AMD64_LINUX_USER64_CS 0x33
|
||
|
||
/* Value of DS segment register:
|
||
LP64 process: 0x0
|
||
X32 process: 0x2b */
|
||
#define AMD64_LINUX_X32_DS 0x2b
|
||
#endif
|
||
|
||
/* Get Linux/x86 target description from running target. */
|
||
|
||
static const struct target_desc *
|
||
x86_linux_read_description (struct target_ops *ops)
|
||
{
|
||
int tid;
|
||
int is_64bit = 0;
|
||
#ifdef __x86_64__
|
||
int is_x32;
|
||
#endif
|
||
static uint64_t xcr0;
|
||
uint64_t xcr0_features_bits;
|
||
|
||
/* GNU/Linux LWP ID's are process ID's. */
|
||
tid = ptid_get_lwp (inferior_ptid);
|
||
if (tid == 0)
|
||
tid = ptid_get_pid (inferior_ptid); /* Not a threaded program. */
|
||
|
||
#ifdef __x86_64__
|
||
{
|
||
unsigned long cs;
|
||
unsigned long ds;
|
||
|
||
/* Get CS register. */
|
||
errno = 0;
|
||
cs = ptrace (PTRACE_PEEKUSER, tid,
|
||
offsetof (struct user_regs_struct, cs), 0);
|
||
if (errno != 0)
|
||
perror_with_name (_("Couldn't get CS register"));
|
||
|
||
is_64bit = cs == AMD64_LINUX_USER64_CS;
|
||
|
||
/* Get DS register. */
|
||
errno = 0;
|
||
ds = ptrace (PTRACE_PEEKUSER, tid,
|
||
offsetof (struct user_regs_struct, ds), 0);
|
||
if (errno != 0)
|
||
perror_with_name (_("Couldn't get DS register"));
|
||
|
||
is_x32 = ds == AMD64_LINUX_X32_DS;
|
||
|
||
if (sizeof (void *) == 4 && is_64bit && !is_x32)
|
||
error (_("Can't debug 64-bit process with 32-bit GDB"));
|
||
}
|
||
#elif HAVE_PTRACE_GETFPXREGS
|
||
if (have_ptrace_getfpxregs == -1)
|
||
{
|
||
elf_fpxregset_t fpxregs;
|
||
|
||
if (ptrace (PTRACE_GETFPXREGS, tid, 0, (int) &fpxregs) < 0)
|
||
{
|
||
have_ptrace_getfpxregs = 0;
|
||
have_ptrace_getregset = 0;
|
||
return tdesc_i386_mmx_linux;
|
||
}
|
||
}
|
||
#endif
|
||
|
||
if (have_ptrace_getregset == -1)
|
||
{
|
||
uint64_t xstateregs[(X86_XSTATE_SSE_SIZE / sizeof (uint64_t))];
|
||
struct iovec iov;
|
||
|
||
iov.iov_base = xstateregs;
|
||
iov.iov_len = sizeof (xstateregs);
|
||
|
||
/* Check if PTRACE_GETREGSET works. */
|
||
if (ptrace (PTRACE_GETREGSET, tid,
|
||
(unsigned int) NT_X86_XSTATE, &iov) < 0)
|
||
have_ptrace_getregset = 0;
|
||
else
|
||
{
|
||
have_ptrace_getregset = 1;
|
||
|
||
/* Get XCR0 from XSAVE extended state. */
|
||
xcr0 = xstateregs[(I386_LINUX_XSAVE_XCR0_OFFSET
|
||
/ sizeof (uint64_t))];
|
||
}
|
||
}
|
||
|
||
/* Check the native XCR0 only if PTRACE_GETREGSET is available. If
|
||
PTRACE_GETREGSET is not available then set xcr0_features_bits to
|
||
zero so that the "no-features" descriptions are returned by the
|
||
switches below. */
|
||
if (have_ptrace_getregset)
|
||
xcr0_features_bits = xcr0 & X86_XSTATE_ALL_MASK;
|
||
else
|
||
xcr0_features_bits = 0;
|
||
|
||
if (is_64bit)
|
||
{
|
||
#ifdef __x86_64__
|
||
switch (xcr0_features_bits)
|
||
{
|
||
case X86_XSTATE_MPX_AVX512_MASK:
|
||
case X86_XSTATE_AVX512_MASK:
|
||
if (is_x32)
|
||
return tdesc_x32_avx512_linux;
|
||
else
|
||
return tdesc_amd64_avx512_linux;
|
||
case X86_XSTATE_MPX_MASK:
|
||
if (is_x32)
|
||
return tdesc_x32_avx_linux; /* No MPX on x32 using AVX. */
|
||
else
|
||
return tdesc_amd64_mpx_linux;
|
||
case X86_XSTATE_AVX_MASK:
|
||
if (is_x32)
|
||
return tdesc_x32_avx_linux;
|
||
else
|
||
return tdesc_amd64_avx_linux;
|
||
default:
|
||
if (is_x32)
|
||
return tdesc_x32_linux;
|
||
else
|
||
return tdesc_amd64_linux;
|
||
}
|
||
#endif
|
||
}
|
||
else
|
||
{
|
||
switch (xcr0_features_bits)
|
||
{
|
||
case X86_XSTATE_MPX_AVX512_MASK:
|
||
case X86_XSTATE_AVX512_MASK:
|
||
return tdesc_i386_avx512_linux;
|
||
case X86_XSTATE_MPX_MASK:
|
||
return tdesc_i386_mpx_linux;
|
||
case X86_XSTATE_AVX_MASK:
|
||
return tdesc_i386_avx_linux;
|
||
default:
|
||
return tdesc_i386_linux;
|
||
}
|
||
}
|
||
|
||
gdb_assert_not_reached ("failed to return tdesc");
|
||
}
|
||
|
||
|
||
/* Enable branch tracing. */
|
||
|
||
static struct btrace_target_info *
|
||
x86_linux_enable_btrace (struct target_ops *self, ptid_t ptid)
|
||
{
|
||
struct btrace_target_info *tinfo;
|
||
struct gdbarch *gdbarch;
|
||
|
||
errno = 0;
|
||
tinfo = linux_enable_btrace (ptid);
|
||
|
||
if (tinfo == NULL)
|
||
error (_("Could not enable branch tracing for %s: %s."),
|
||
target_pid_to_str (ptid), safe_strerror (errno));
|
||
|
||
/* Fill in the size of a pointer in bits. */
|
||
gdbarch = target_thread_architecture (ptid);
|
||
tinfo->ptr_bits = gdbarch_ptr_bit (gdbarch);
|
||
|
||
return tinfo;
|
||
}
|
||
|
||
/* Disable branch tracing. */
|
||
|
||
static void
|
||
x86_linux_disable_btrace (struct target_ops *self,
|
||
struct btrace_target_info *tinfo)
|
||
{
|
||
enum btrace_error errcode = linux_disable_btrace (tinfo);
|
||
|
||
if (errcode != BTRACE_ERR_NONE)
|
||
error (_("Could not disable branch tracing."));
|
||
}
|
||
|
||
/* Teardown branch tracing. */
|
||
|
||
static void
|
||
x86_linux_teardown_btrace (struct target_ops *self,
|
||
struct btrace_target_info *tinfo)
|
||
{
|
||
/* Ignore errors. */
|
||
linux_disable_btrace (tinfo);
|
||
}
|
||
|
||
static enum btrace_error
|
||
x86_linux_read_btrace (struct target_ops *self,
|
||
VEC (btrace_block_s) **data,
|
||
struct btrace_target_info *btinfo,
|
||
enum btrace_read_type type)
|
||
{
|
||
return linux_read_btrace (data, btinfo, type);
|
||
}
|
||
|
||
|
||
/* Helper for ps_get_thread_area. Sets BASE_ADDR to a pointer to
|
||
the thread local storage (or its descriptor) and returns PS_OK
|
||
on success. Returns PS_ERR on failure. */
|
||
|
||
ps_err_e
|
||
x86_linux_get_thread_area (pid_t pid, void *addr, unsigned int *base_addr)
|
||
{
|
||
/* NOTE: cagney/2003-08-26: The definition of this buffer is found
|
||
in the kernel header <asm-i386/ldt.h>. It, after padding, is 4 x
|
||
4 byte integers in size: `entry_number', `base_addr', `limit',
|
||
and a bunch of status bits.
|
||
|
||
The values returned by this ptrace call should be part of the
|
||
regcache buffer, and ps_get_thread_area should channel its
|
||
request through the regcache. That way remote targets could
|
||
provide the value using the remote protocol and not this direct
|
||
call.
|
||
|
||
Is this function needed? I'm guessing that the `base' is the
|
||
address of a descriptor that libthread_db uses to find the
|
||
thread local address base that GDB needs. Perhaps that
|
||
descriptor is defined by the ABI. Anyway, given that
|
||
libthread_db calls this function without prompting (gdb
|
||
requesting tls base) I guess it needs info in there anyway. */
|
||
unsigned int desc[4];
|
||
|
||
/* This code assumes that "int" is 32 bits and that
|
||
GET_THREAD_AREA returns no more than 4 int values. */
|
||
gdb_assert (sizeof (int) == 4);
|
||
|
||
#ifndef PTRACE_GET_THREAD_AREA
|
||
#define PTRACE_GET_THREAD_AREA 25
|
||
#endif
|
||
|
||
if (ptrace (PTRACE_GET_THREAD_AREA, pid, addr, &desc) < 0)
|
||
return PS_ERR;
|
||
|
||
*base_addr = desc[1];
|
||
return PS_OK;
|
||
}
|
||
|
||
|
||
/* Create an x86 GNU/Linux target. */
|
||
|
||
struct target_ops *
|
||
x86_linux_create_target (void)
|
||
{
|
||
/* Fill in the generic GNU/Linux methods. */
|
||
struct target_ops *t = linux_target ();
|
||
|
||
/* Initialize the debug register function vectors. */
|
||
x86_use_watchpoints (t);
|
||
x86_dr_low.set_control = x86_linux_dr_set_control;
|
||
x86_dr_low.set_addr = x86_linux_dr_set_addr;
|
||
x86_dr_low.get_addr = x86_linux_dr_get_addr;
|
||
x86_dr_low.get_status = x86_linux_dr_get_status;
|
||
x86_dr_low.get_control = x86_linux_dr_get_control;
|
||
x86_set_debug_register_length (sizeof (void *));
|
||
|
||
/* Override the GNU/Linux inferior startup hook. */
|
||
super_post_startup_inferior = t->to_post_startup_inferior;
|
||
t->to_post_startup_inferior = x86_linux_child_post_startup_inferior;
|
||
|
||
/* Add the description reader. */
|
||
t->to_read_description = x86_linux_read_description;
|
||
|
||
/* Add btrace methods. */
|
||
t->to_supports_btrace = linux_supports_btrace;
|
||
t->to_enable_btrace = x86_linux_enable_btrace;
|
||
t->to_disable_btrace = x86_linux_disable_btrace;
|
||
t->to_teardown_btrace = x86_linux_teardown_btrace;
|
||
t->to_read_btrace = x86_linux_read_btrace;
|
||
|
||
return t;
|
||
}
|
||
|
||
/* Add an x86 GNU/Linux target. */
|
||
|
||
void
|
||
x86_linux_add_target (struct target_ops *t)
|
||
{
|
||
linux_nat_add_target (t);
|
||
linux_nat_set_new_thread (t, x86_linux_new_thread);
|
||
linux_nat_set_new_fork (t, x86_linux_new_fork);
|
||
linux_nat_set_forget_process (t, x86_forget_process);
|
||
linux_nat_set_prepare_to_resume (t, x86_linux_prepare_to_resume);
|
||
}
|