mirror of
https://sourceware.org/git/binutils-gdb.git
synced 2024-12-21 04:42:53 +08:00
fbf3c4b979
In a linux kernel mailing list discussion, it was mentioned that "gdb has
this odd thing where it takes the 64-bit vs 32-bit data for the whole process
from one thread, and picks the worst possible thread to do it (ie explicitly
not even the main thread, ...)" [1].
The picking of the thread is done here in
x86_linux_nat_target::read_description:
...
/* GNU/Linux LWP ID's are process ID's. */
tid = inferior_ptid.lwp ();
if (tid == 0)
tid = inferior_ptid.pid (); /* Not a threaded program. */
...
To understand what this code does, let's investigate a scenario in which
inferior_ptid.lwp () != inferior_ptid.pid ().
Say we start exec jit-attach-pie, identified with pid x. The main thread
starts another thread that sleeps, and then the main thread waits for the
sleeping thread. So we have two threads, identified with LWP IDs x and x+1:
...
PID LWP CMD
x x ./jit-attach-pie
x x+1 ./jit-attach-pie
...
[ The thread with LWP x is known as the thread group leader. ]
When attaching to this exec using the pid, gdb does a stop_all_threads which
iterates over all the threads, first LWP x, and then LWP x+1.
So the state we arrive with at x86_linux_nat_target::read_description is:
...
(gdb) p inferior_ptid
$1 = {m_pid = x, m_lwp = x+1, m_tid = 0}
...
and consequently we probe 64/32-bitness from thread LWP x+1.
[ Note that this is different from when gdb doesn't attach but instead
launches the exec itself, in which case there's just one thread to begin with,
and consequently the probed thread is LWP x. ]
According to aforementioned remark, a better choice would have been the main
thread, that is, LWP x.
This patch implement that choice, by simply doing:
...
tid = inferior_ptid.pid ();
...
The fact that gdb makes a per-process permanent choice for 64/32-bitness is a
problem in itself: each thread can be in either 64 or 32 bit mode, and change
forth and back. That is a problem that this patch doesn't fix.
Now finally: why does this matter in the context of the linux kernel
discussion? The discussion was related to a patch that exposed io_uring
threads to user-space. This made it possible that one of those threads would
be picked out to select 64/32-bitness. Given that such threads are atypical
user-space threads in the sense that they don't return to user-space and don't
have a userspace register state, reading their registers returns garbage, and
so it could f.i. occur that in a 64-bit process with all normal user-space
threads in 64-bit mode, the probing would return 32-bit.
It may be that this is worked-around on the kernel side by providing userspace
register state in those threads such that current gdb is happy. Nevertheless,
it seems prudent to fix this on the gdb size as well.
Tested on x86_64-linux.
[1] https://lore.kernel.org/io-uring/CAHk-=wh0KoEZXPYMGkfkeVEerSCEF1AiCZSvz9TRrx=Kj74D+Q@mail.gmail.com/
gdb/ChangeLog:
2021-05-23 Tom de Vries <tdevries@suse.de>
PR tdep/27822
* target.h (struct target_ops): Mention target_thread_architecture in
read_description comment.
* x86-linux-nat.c (x86_linux_nat_target::read_description): Use
pid to determine if process is 64-bit or 32-bit.
* aarch64-linux-nat.c (aarch64_linux_nat_target::read_description):
Same.
* ppc-linux-nat.c (ppc_linux_nat_target::read_description): Same.
* riscv-linux-nat.c (riscv_linux_nat_target::read_description): Same.
* s390-linux-nat.c (s390_linux_nat_target::read_description): Same.
* arm-linux-nat.c (arm_linux_nat_target::read_description): Same.
Likewise, use pid to determine if kernel supports reading VFP
registers.
338 lines
9.4 KiB
C
338 lines
9.4 KiB
C
/* Native-dependent code for GNU/Linux RISC-V.
|
|
Copyright (C) 2018-2021 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 "regcache.h"
|
|
#include "gregset.h"
|
|
#include "linux-nat.h"
|
|
#include "riscv-tdep.h"
|
|
#include "inferior.h"
|
|
|
|
#include "elf/common.h"
|
|
|
|
#include "nat/riscv-linux-tdesc.h"
|
|
|
|
#include <sys/ptrace.h>
|
|
|
|
/* Work around glibc header breakage causing ELF_NFPREG not to be usable. */
|
|
#ifndef NFPREG
|
|
# define NFPREG 33
|
|
#endif
|
|
|
|
/* RISC-V Linux native additions to the default linux support. */
|
|
|
|
class riscv_linux_nat_target final : public linux_nat_target
|
|
{
|
|
public:
|
|
/* Add our register access methods. */
|
|
void fetch_registers (struct regcache *regcache, int regnum) override;
|
|
void store_registers (struct regcache *regcache, int regnum) override;
|
|
|
|
/* Read suitable target description. */
|
|
const struct target_desc *read_description () override;
|
|
};
|
|
|
|
static riscv_linux_nat_target the_riscv_linux_nat_target;
|
|
|
|
/* Copy general purpose register REGNUM (or all gp regs if REGNUM == -1)
|
|
from regset GREGS into REGCACHE. */
|
|
|
|
static void
|
|
supply_gregset_regnum (struct regcache *regcache, const prgregset_t *gregs,
|
|
int regnum)
|
|
{
|
|
int i;
|
|
const elf_greg_t *regp = *gregs;
|
|
|
|
if (regnum == -1)
|
|
{
|
|
/* We only support the integer registers and PC here. */
|
|
for (i = RISCV_ZERO_REGNUM + 1; i < RISCV_PC_REGNUM; i++)
|
|
regcache->raw_supply (i, regp + i);
|
|
|
|
/* GDB stores PC in reg 32. Linux kernel stores it in reg 0. */
|
|
regcache->raw_supply (32, regp + 0);
|
|
|
|
/* Fill the inaccessible zero register with zero. */
|
|
regcache->raw_supply_zeroed (0);
|
|
}
|
|
else if (regnum == RISCV_ZERO_REGNUM)
|
|
regcache->raw_supply_zeroed (0);
|
|
else if (regnum > RISCV_ZERO_REGNUM && regnum < RISCV_PC_REGNUM)
|
|
regcache->raw_supply (regnum, regp + regnum);
|
|
else if (regnum == RISCV_PC_REGNUM)
|
|
regcache->raw_supply (32, regp + 0);
|
|
}
|
|
|
|
/* Copy all general purpose registers from regset GREGS into REGCACHE. */
|
|
|
|
void
|
|
supply_gregset (struct regcache *regcache, const prgregset_t *gregs)
|
|
{
|
|
supply_gregset_regnum (regcache, gregs, -1);
|
|
}
|
|
|
|
/* Copy floating point register REGNUM (or all fp regs if REGNUM == -1)
|
|
from regset FPREGS into REGCACHE. */
|
|
|
|
static void
|
|
supply_fpregset_regnum (struct regcache *regcache, const prfpregset_t *fpregs,
|
|
int regnum)
|
|
{
|
|
int flen = register_size (regcache->arch (), RISCV_FIRST_FP_REGNUM);
|
|
union
|
|
{
|
|
const prfpregset_t *fpregs;
|
|
const gdb_byte *buf;
|
|
}
|
|
fpbuf = { .fpregs = fpregs };
|
|
int i;
|
|
|
|
if (regnum == -1)
|
|
{
|
|
/* We only support the FP registers and FCSR here. */
|
|
for (i = RISCV_FIRST_FP_REGNUM;
|
|
i <= RISCV_LAST_FP_REGNUM;
|
|
i++, fpbuf.buf += flen)
|
|
regcache->raw_supply (i, fpbuf.buf);
|
|
|
|
regcache->raw_supply (RISCV_CSR_FCSR_REGNUM, fpbuf.buf);
|
|
}
|
|
else if (regnum >= RISCV_FIRST_FP_REGNUM && regnum <= RISCV_LAST_FP_REGNUM)
|
|
{
|
|
fpbuf.buf += flen * (regnum - RISCV_FIRST_FP_REGNUM);
|
|
regcache->raw_supply (regnum, fpbuf.buf);
|
|
}
|
|
else if (regnum == RISCV_CSR_FCSR_REGNUM)
|
|
{
|
|
fpbuf.buf += flen * (RISCV_LAST_FP_REGNUM - RISCV_FIRST_FP_REGNUM + 1);
|
|
regcache->raw_supply (RISCV_CSR_FCSR_REGNUM, fpbuf.buf);
|
|
}
|
|
}
|
|
|
|
/* Copy all floating point registers from regset FPREGS into REGCACHE. */
|
|
|
|
void
|
|
supply_fpregset (struct regcache *regcache, const prfpregset_t *fpregs)
|
|
{
|
|
supply_fpregset_regnum (regcache, fpregs, -1);
|
|
}
|
|
|
|
/* Copy general purpose register REGNUM (or all gp regs if REGNUM == -1)
|
|
from REGCACHE into regset GREGS. */
|
|
|
|
void
|
|
fill_gregset (const struct regcache *regcache, prgregset_t *gregs, int regnum)
|
|
{
|
|
elf_greg_t *regp = *gregs;
|
|
|
|
if (regnum == -1)
|
|
{
|
|
/* We only support the integer registers and PC here. */
|
|
for (int i = RISCV_ZERO_REGNUM + 1; i < RISCV_PC_REGNUM; i++)
|
|
regcache->raw_collect (i, regp + i);
|
|
|
|
regcache->raw_collect (32, regp + 0);
|
|
}
|
|
else if (regnum == RISCV_ZERO_REGNUM)
|
|
/* Nothing to do here. */
|
|
;
|
|
else if (regnum > RISCV_ZERO_REGNUM && regnum < RISCV_PC_REGNUM)
|
|
regcache->raw_collect (regnum, regp + regnum);
|
|
else if (regnum == RISCV_PC_REGNUM)
|
|
regcache->raw_collect (32, regp + 0);
|
|
}
|
|
|
|
/* Copy floating point register REGNUM (or all fp regs if REGNUM == -1)
|
|
from REGCACHE into regset FPREGS. */
|
|
|
|
void
|
|
fill_fpregset (const struct regcache *regcache, prfpregset_t *fpregs,
|
|
int regnum)
|
|
{
|
|
int flen = register_size (regcache->arch (), RISCV_FIRST_FP_REGNUM);
|
|
union
|
|
{
|
|
prfpregset_t *fpregs;
|
|
gdb_byte *buf;
|
|
}
|
|
fpbuf = { .fpregs = fpregs };
|
|
int i;
|
|
|
|
if (regnum == -1)
|
|
{
|
|
/* We only support the FP registers and FCSR here. */
|
|
for (i = RISCV_FIRST_FP_REGNUM;
|
|
i <= RISCV_LAST_FP_REGNUM;
|
|
i++, fpbuf.buf += flen)
|
|
regcache->raw_collect (i, fpbuf.buf);
|
|
|
|
regcache->raw_collect (RISCV_CSR_FCSR_REGNUM, fpbuf.buf);
|
|
}
|
|
else if (regnum >= RISCV_FIRST_FP_REGNUM && regnum <= RISCV_LAST_FP_REGNUM)
|
|
{
|
|
fpbuf.buf += flen * (regnum - RISCV_FIRST_FP_REGNUM);
|
|
regcache->raw_collect (regnum, fpbuf.buf);
|
|
}
|
|
else if (regnum == RISCV_CSR_FCSR_REGNUM)
|
|
{
|
|
fpbuf.buf += flen * (RISCV_LAST_FP_REGNUM - RISCV_FIRST_FP_REGNUM + 1);
|
|
regcache->raw_collect (RISCV_CSR_FCSR_REGNUM, fpbuf.buf);
|
|
}
|
|
}
|
|
|
|
/* Return a target description for the current target. */
|
|
|
|
const struct target_desc *
|
|
riscv_linux_nat_target::read_description ()
|
|
{
|
|
const struct riscv_gdbarch_features features
|
|
= riscv_linux_read_features (inferior_ptid.pid ());
|
|
return riscv_lookup_target_description (features);
|
|
}
|
|
|
|
/* Fetch REGNUM (or all registers if REGNUM == -1) from the target
|
|
into REGCACHE using PTRACE_GETREGSET. */
|
|
|
|
void
|
|
riscv_linux_nat_target::fetch_registers (struct regcache *regcache, int regnum)
|
|
{
|
|
int tid;
|
|
|
|
tid = get_ptrace_pid (regcache->ptid());
|
|
|
|
if ((regnum >= RISCV_ZERO_REGNUM && regnum <= RISCV_PC_REGNUM)
|
|
|| (regnum == -1))
|
|
{
|
|
struct iovec iov;
|
|
elf_gregset_t regs;
|
|
|
|
iov.iov_base = ®s;
|
|
iov.iov_len = sizeof (regs);
|
|
|
|
if (ptrace (PTRACE_GETREGSET, tid, NT_PRSTATUS,
|
|
(PTRACE_TYPE_ARG3) &iov) == -1)
|
|
perror_with_name (_("Couldn't get registers"));
|
|
else
|
|
supply_gregset_regnum (regcache, ®s, regnum);
|
|
}
|
|
|
|
if ((regnum >= RISCV_FIRST_FP_REGNUM
|
|
&& regnum <= RISCV_LAST_FP_REGNUM)
|
|
|| (regnum == RISCV_CSR_FCSR_REGNUM)
|
|
|| (regnum == -1))
|
|
{
|
|
struct iovec iov;
|
|
elf_fpregset_t regs;
|
|
|
|
iov.iov_base = ®s;
|
|
iov.iov_len = ELF_NFPREG * register_size (regcache->arch (),
|
|
RISCV_FIRST_FP_REGNUM);
|
|
gdb_assert (iov.iov_len <= sizeof (regs));
|
|
|
|
if (ptrace (PTRACE_GETREGSET, tid, NT_FPREGSET,
|
|
(PTRACE_TYPE_ARG3) &iov) == -1)
|
|
perror_with_name (_("Couldn't get registers"));
|
|
else
|
|
supply_fpregset_regnum (regcache, ®s, regnum);
|
|
}
|
|
|
|
if ((regnum == RISCV_CSR_MISA_REGNUM)
|
|
|| (regnum == -1))
|
|
{
|
|
/* TODO: Need to add a ptrace call for this. */
|
|
regcache->raw_supply_zeroed (RISCV_CSR_MISA_REGNUM);
|
|
}
|
|
|
|
/* Access to other CSRs has potential security issues, don't support them for
|
|
now. */
|
|
}
|
|
|
|
/* Store REGNUM (or all registers if REGNUM == -1) to the target
|
|
from REGCACHE using PTRACE_SETREGSET. */
|
|
|
|
void
|
|
riscv_linux_nat_target::store_registers (struct regcache *regcache, int regnum)
|
|
{
|
|
int tid;
|
|
|
|
tid = get_ptrace_pid (regcache->ptid ());
|
|
|
|
if ((regnum >= RISCV_ZERO_REGNUM && regnum <= RISCV_PC_REGNUM)
|
|
|| (regnum == -1))
|
|
{
|
|
struct iovec iov;
|
|
elf_gregset_t regs;
|
|
|
|
iov.iov_base = ®s;
|
|
iov.iov_len = sizeof (regs);
|
|
|
|
if (ptrace (PTRACE_GETREGSET, tid, NT_PRSTATUS,
|
|
(PTRACE_TYPE_ARG3) &iov) == -1)
|
|
perror_with_name (_("Couldn't get registers"));
|
|
else
|
|
{
|
|
fill_gregset (regcache, ®s, regnum);
|
|
|
|
if (ptrace (PTRACE_SETREGSET, tid, NT_PRSTATUS,
|
|
(PTRACE_TYPE_ARG3) &iov) == -1)
|
|
perror_with_name (_("Couldn't set registers"));
|
|
}
|
|
}
|
|
|
|
if ((regnum >= RISCV_FIRST_FP_REGNUM
|
|
&& regnum <= RISCV_LAST_FP_REGNUM)
|
|
|| (regnum == RISCV_CSR_FCSR_REGNUM)
|
|
|| (regnum == -1))
|
|
{
|
|
struct iovec iov;
|
|
elf_fpregset_t regs;
|
|
|
|
iov.iov_base = ®s;
|
|
iov.iov_len = ELF_NFPREG * register_size (regcache->arch (),
|
|
RISCV_FIRST_FP_REGNUM);
|
|
gdb_assert (iov.iov_len <= sizeof (regs));
|
|
|
|
if (ptrace (PTRACE_GETREGSET, tid, NT_FPREGSET,
|
|
(PTRACE_TYPE_ARG3) &iov) == -1)
|
|
perror_with_name (_("Couldn't get registers"));
|
|
else
|
|
{
|
|
fill_fpregset (regcache, ®s, regnum);
|
|
|
|
if (ptrace (PTRACE_SETREGSET, tid, NT_FPREGSET,
|
|
(PTRACE_TYPE_ARG3) &iov) == -1)
|
|
perror_with_name (_("Couldn't set registers"));
|
|
}
|
|
}
|
|
|
|
/* Access to CSRs has potential security issues, don't support them for
|
|
now. */
|
|
}
|
|
|
|
/* Initialize RISC-V Linux native support. */
|
|
|
|
void _initialize_riscv_linux_nat ();
|
|
void
|
|
_initialize_riscv_linux_nat ()
|
|
{
|
|
/* Register the target. */
|
|
linux_target = &the_riscv_linux_nat_target;
|
|
add_inf_child_target (&the_riscv_linux_nat_target);
|
|
}
|