mirror of
https://sourceware.org/git/binutils-gdb.git
synced 2024-12-21 04:42:53 +08:00
82d1f134cc
In the context of ROCm-gdb [1], the ROCm target sits on top of the linux-nat target. when a process forks, it needs to carry over some data from the forking inferior to the fork child inferior. Ideally, the ROCm target would implement the follow_fork target_ops method, but there are some small problems. This patch fixes these, which helps the ROCm target, but also makes things more consistent and a bit nicer in general, I believe. The main problem is: when follow-fork-mode is "parent", target_follow_fork is called with the parent as the current inferior. When it's "child", target_follow_fork is called with the child as the current inferior. This means that target_follow_fork is sometimes called on the parent's target stack and sometimes on the child's target stack. The parent's target stack may contain targets above the process target, such as the ROCm target. So if follow-fork-child is "parent", the ROCm target would get notified of the fork and do whatever is needed. But the child's target stack, at that moment, only contains the exec and process target copied over from the parent. The child's target stack is set up by follow_fork_inferior, before calling target_follow_fork. In that case, the ROCm target wouldn't get notified of the fork. For consistency, I think it would be good to always call target_follow_fork on the parent inferior's target stack. I think it makes sense as a way to indicate "this inferior has called fork, do whatever is needed". The desired outcome of the fork (whether an inferior is created for the child, do we need to detach from the child) can be indicated by passed parameter. I therefore propose these changes: - make follow_fork_inferior always call target_follow_fork with the parent as the current inferior. That lets all targets present on the parent's target stack do some fork-related handling and push themselves on the fork child's target stack if needed. For this purpose, pass the child inferior down to target_follow_fork and follow_fork implementations. This is nullptr if no inferior is created for the child, because we want to detach from it. - as a result, in follow_fork_inferior, detach from the parent inferior (if needed) only after the target_follow_fork call. This is needed because we want to call target_follow_fork before the parent's target stack is torn down. - hand over to the targets in the parent's target stack (including the process target) the responsibility to push themselves, if needed, to the child's target stack. Also hand over the responsibility to the process target, at the same time, to create the child's initial thread (just like we do for follow_exec). - pass the child inferior to exec_on_vfork, so we don't need to swap the current inferior between parent and child. Nothing in exec_on_vfork depends on the current inferior, after this change. Although this could perhaps be replaced with just having the exec target implement follow_fork and push itself in the child's target stack, like the process target does... We would just need to make sure the process target calls beneath()->follow_fork(...). I'm not sure about this one. gdb/ChangeLog: * target.h (struct target_ops) <follow_fork>: Add inferior* parameter. (target_follow_fork): Likewise. * target.c (default_follow_fork): Likewise. (target_follow_fork): Likewise. * fbsd-nat.h (class fbsd_nat_target) <follow_fork>: Likewise. (fbsd_nat_target::follow_fork): Likewise, and call inf_ptrace_target::follow_fork. * linux-nat.h (class linux_nat_target) <follow_fork>: Likewise. * linux-nat.c (linux_nat_target::follow_fork): Likewise, and call inf_ptrace_target::follow_fork. * obsd-nat.h (obsd_nat_target) <follow_fork>: Likewise. * obsd-nat.c (obsd_nat_target::follow_fork): Likewise, and call inf_ptrace_target::follow_fork. * remote.c (class remote_target) <follow_fork>: Likewise. (remote_target::follow_fork): Likewise, and call process_stratum_target::follow_fork. * process-stratum-target.h (class process_stratum_target) <follow_fork>: New. * process-stratum-target.c (process_stratum_target::follow_fork): New. * target-delegates.c: Re-generate. [1] https://github.com/ROCm-Developer-Tools/ROCgdb Change-Id: I460bd0af850f0485e8aed4b24c6d8262a4c69929
152 lines
4.8 KiB
C++
152 lines
4.8 KiB
C++
/* Native-dependent code for FreeBSD.
|
|
|
|
Copyright (C) 2004-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/>. */
|
|
|
|
#ifndef FBSD_NAT_H
|
|
#define FBSD_NAT_H
|
|
|
|
#include "inf-ptrace.h"
|
|
#include "regcache.h"
|
|
#include "regset.h"
|
|
#include <osreldate.h>
|
|
#include <sys/proc.h>
|
|
|
|
/* FreeBSD kernels 11.3 and later report valid si_code values for
|
|
SIGTRAP on all architectures. Older FreeBSD kernels that supported
|
|
TRAP_BRKPT did not report valid values for MIPS and sparc64. Even
|
|
older kernels without TRAP_BRKPT support did not report valid
|
|
values on any architecture. */
|
|
#if (__FreeBSD_kernel_version >= 1102502) || (__FreeBSD_version >= 1102502)
|
|
# define USE_SIGTRAP_SIGINFO
|
|
#elif defined(TRAP_BRKPT)
|
|
# if !defined(__mips__) && !defined(__sparc64__)
|
|
# define USE_SIGTRAP_SIGINFO
|
|
# endif
|
|
#endif
|
|
|
|
/* A prototype FreeBSD target. */
|
|
|
|
class fbsd_nat_target : public inf_ptrace_target
|
|
{
|
|
public:
|
|
char *pid_to_exec_file (int pid) override;
|
|
|
|
int find_memory_regions (find_memory_region_ftype func, void *data) override;
|
|
|
|
bool info_proc (const char *, enum info_proc_what) override;
|
|
|
|
enum target_xfer_status xfer_partial (enum target_object object,
|
|
const char *annex,
|
|
gdb_byte *readbuf,
|
|
const gdb_byte *writebuf,
|
|
ULONGEST offset, ULONGEST len,
|
|
ULONGEST *xfered_len) override;
|
|
|
|
bool thread_alive (ptid_t ptid) override;
|
|
std::string pid_to_str (ptid_t) override;
|
|
|
|
#ifdef HAVE_STRUCT_PTRACE_LWPINFO_PL_TDNAME
|
|
const char *thread_name (struct thread_info *) override;
|
|
#endif
|
|
|
|
void update_thread_list () override;
|
|
|
|
thread_control_capabilities get_thread_control_capabilities () override
|
|
{ return tc_schedlock; }
|
|
|
|
void create_inferior (const char *, const std::string &,
|
|
char **, int) override;
|
|
|
|
void resume (ptid_t, int, enum gdb_signal) override;
|
|
|
|
ptid_t wait (ptid_t, struct target_waitstatus *, target_wait_flags) override;
|
|
|
|
void post_startup_inferior (ptid_t) override;
|
|
void post_attach (int) override;
|
|
|
|
#ifdef USE_SIGTRAP_SIGINFO
|
|
bool supports_stopped_by_sw_breakpoint () override;
|
|
bool stopped_by_sw_breakpoint () override;
|
|
#endif
|
|
|
|
#ifdef TDP_RFPPWAIT
|
|
void follow_fork (inferior *, ptid_t, target_waitkind, bool, bool) override;
|
|
|
|
int insert_fork_catchpoint (int) override;
|
|
int remove_fork_catchpoint (int) override;
|
|
|
|
int insert_vfork_catchpoint (int) override;
|
|
int remove_vfork_catchpoint (int) override;
|
|
#endif
|
|
|
|
int insert_exec_catchpoint (int) override;
|
|
int remove_exec_catchpoint (int) override;
|
|
|
|
#ifdef HAVE_STRUCT_PTRACE_LWPINFO_PL_SYSCALL_CODE
|
|
int set_syscall_catchpoint (int, bool, int, gdb::array_view<const int>)
|
|
override;
|
|
#endif
|
|
|
|
bool supports_multi_process () override;
|
|
|
|
bool supports_disable_randomization () override;
|
|
|
|
private:
|
|
/* Helper routines for use in fetch_registers and store_registers in
|
|
subclasses. These routines fetch and store a single set of
|
|
registers described by REGSET. The REGSET's 'regmap' field must
|
|
point to an array of 'struct regcache_map_entry'.
|
|
|
|
FETCH_OP is a ptrace operation to fetch the set of registers from
|
|
a native thread. STORE_OP is a ptrace operation to store the set
|
|
of registers to a native thread.
|
|
|
|
The caller must provide storage for the set of registers in REGS,
|
|
and SIZE is the size of the storage. */
|
|
|
|
void fetch_register_set (struct regcache *regcache, int regnum, int fetch_op,
|
|
const struct regset *regset, void *regs, size_t size);
|
|
|
|
void store_register_set (struct regcache *regcache, int regnum, int fetch_op,
|
|
int store_op, const struct regset *regset,
|
|
void *regs, size_t size);
|
|
protected:
|
|
/* Wrapper versions of the above helpers which accept a register set
|
|
type such as 'struct reg' or 'struct fpreg'. */
|
|
|
|
template <class Regset>
|
|
void fetch_register_set (struct regcache *regcache, int regnum, int fetch_op,
|
|
const struct regset *regset)
|
|
{
|
|
Regset regs;
|
|
fetch_register_set (regcache, regnum, fetch_op, regset, ®s,
|
|
sizeof (regs));
|
|
}
|
|
|
|
template <class Regset>
|
|
void store_register_set (struct regcache *regcache, int regnum, int fetch_op,
|
|
int store_op, const struct regset *regset)
|
|
{
|
|
Regset regs;
|
|
store_register_set (regcache, regnum, fetch_op, store_op, regset, ®s,
|
|
sizeof (regs));
|
|
}
|
|
};
|
|
|
|
#endif /* fbsd-nat.h */
|