X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=gdb%2Flinux-nat.h;h=e02611fcf14cff52f2fc0343be37ab3e92a4939f;hb=5b6d1e4fa4fc6827c7b3f0e99ff120dfa14d65d2;hp=8c2ceb5c7f038efb2b10f59d681b1987d972623c;hpb=2db9a4275ceada4aad3443dc157b96dd2e23afc0;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/linux-nat.h b/gdb/linux-nat.h index 8c2ceb5c7f..e02611fcf1 100644 --- a/gdb/linux-nat.h +++ b/gdb/linux-nat.h @@ -1,6 +1,6 @@ /* Native debugging support for GNU/Linux (LWP layer). - Copyright (C) 2000-2015 Free Software Foundation, Inc. + Copyright (C) 2000-2020 Free Software Foundation, Inc. This file is part of GDB. @@ -17,30 +17,181 @@ You should have received a copy of the GNU General Public License along with this program. If not, see . */ -#include "target.h" +#ifndef LINUX_NAT_H +#define LINUX_NAT_H +#include "nat/linux-nat.h" +#include "inf-ptrace.h" +#include "target.h" #include -struct arch_lwp_info; - -/* Reasons an LWP last stopped. */ +/* A prototype generic GNU/Linux target. A concrete instance should + override it with local methods. */ -enum lwp_stop_reason +class linux_nat_target : public inf_ptrace_target { - /* Either not stopped, or stopped for a reason that doesn't require - special tracking. */ - LWP_STOPPED_BY_NO_REASON, +public: + linux_nat_target (); + ~linux_nat_target () override = 0; + + thread_control_capabilities get_thread_control_capabilities () override + { return tc_schedlock; } + + void create_inferior (const char *, const std::string &, + char **, int) override; + + void attach (const char *, int) override; + + void detach (inferior *, int) override; + + void resume (ptid_t, int, enum gdb_signal) override; + + ptid_t wait (ptid_t, struct target_waitstatus *, int) override; + + void pass_signals (gdb::array_view) 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; + + void kill () override; + + void mourn_inferior () override; + bool thread_alive (ptid_t ptid) override; + + void update_thread_list () override; + + std::string pid_to_str (ptid_t) override; + + const char *thread_name (struct thread_info *) override; + + struct address_space *thread_address_space (ptid_t) override; + + bool stopped_by_watchpoint () override; + + bool stopped_data_address (CORE_ADDR *) override; + + bool stopped_by_sw_breakpoint () override; + bool supports_stopped_by_sw_breakpoint () override; + + bool stopped_by_hw_breakpoint () override; + bool supports_stopped_by_hw_breakpoint () override; + + void thread_events (int) override; + + bool can_async_p () override; + bool is_async_p () override; + + bool supports_non_stop () override; + bool always_non_stop_p () override; + + int async_wait_fd () override; + void async (int) override; + + void close () override; + + void stop (ptid_t) override; + + bool supports_multi_process () override; + + bool supports_disable_randomization () override; + + int core_of_thread (ptid_t ptid) override; + + bool filesystem_is_local () override; + + int fileio_open (struct inferior *inf, const char *filename, + int flags, int mode, int warn_if_slow, + int *target_errno) override; + + gdb::optional + fileio_readlink (struct inferior *inf, + const char *filename, + int *target_errno) override; + + int fileio_unlink (struct inferior *inf, + const char *filename, + int *target_errno) override; - /* Stopped by a software breakpoint. */ - LWP_STOPPED_BY_SW_BREAKPOINT, + int insert_fork_catchpoint (int) override; + int remove_fork_catchpoint (int) override; + int insert_vfork_catchpoint (int) override; + int remove_vfork_catchpoint (int) override; - /* Stopped by a hardware breakpoint. */ - LWP_STOPPED_BY_HW_BREAKPOINT, + int insert_exec_catchpoint (int) override; + int remove_exec_catchpoint (int) override; - /* Stopped by a watchpoint. */ - LWP_STOPPED_BY_WATCHPOINT + int set_syscall_catchpoint (int pid, bool needed, int any_count, + gdb::array_view syscall_counts) override; + + char *pid_to_exec_file (int pid) override; + + void post_startup_inferior (ptid_t) override; + + void post_attach (int) override; + + int follow_fork (int, int) override; + + std::vector + static_tracepoint_markers_by_strid (const char *id) override; + + /* Methods that are meant to overridden by the concrete + arch-specific target instance. */ + + virtual void low_resume (ptid_t ptid, int step, enum gdb_signal sig) + { inf_ptrace_target::resume (ptid, step, sig); } + + virtual bool low_stopped_by_watchpoint () + { return false; } + + virtual bool low_stopped_data_address (CORE_ADDR *addr_p) + { return false; } + + /* The method to call, if any, when a new thread is attached. */ + virtual void low_new_thread (struct lwp_info *) + {} + + /* The method to call, if any, when a thread is destroyed. */ + virtual void low_delete_thread (struct arch_lwp_info *lp) + { + gdb_assert (lp == NULL); + } + + /* The method to call, if any, when a new fork is attached. */ + virtual void low_new_fork (struct lwp_info *parent, pid_t child_pid) + {} + + /* The method to call, if any, when a process is no longer + attached. */ + virtual void low_forget_process (pid_t pid) + {} + + /* Hook to call prior to resuming a thread. */ + virtual void low_prepare_to_resume (struct lwp_info *) + {} + + /* Convert a ptrace/host siginfo object, into/from the siginfo in + the layout of the inferiors' architecture. Returns true if any + conversion was done; false otherwise, in which case the caller + does a straight memcpy. If DIRECTION is 1, then copy from INF to + PTRACE. If DIRECTION is 0, copy from PTRACE to INF. */ + virtual bool low_siginfo_fixup (siginfo_t *ptrace, gdb_byte *inf, + int direction) + { return false; } + + /* SIGTRAP-like breakpoint status events recognizer. The default + recognizes SIGTRAP only. */ + virtual bool low_status_is_event (int status); }; +/* The final/concrete instance. */ +extern linux_nat_target *linux_target; + +struct arch_lwp_info; + /* Structure describing an LWP. This is public only for the purposes of ALL_LWPS; target-specific code should generally not access it directly. */ @@ -55,11 +206,6 @@ struct lwp_info next time we see this LWP stop. */ int must_set_ptrace_flags; - /* Non-zero if this LWP is cloned. In this context "cloned" means - that the LWP is reporting to its parent using a signal other than - SIGCHLD. */ - int cloned; - /* Non-zero if we sent this LWP a SIGSTOP (but the LWP didn't report it back yet). */ int signalled; @@ -93,7 +239,7 @@ struct lwp_info /* The reason the LWP last stopped, if we need to track it (breakpoint, watchpoint, etc.) */ - enum lwp_stop_reason stop_reason; + enum target_stop_reason stop_reason; /* On architectures where it is possible to know the data address of a triggered watchpoint, STOPPED_DATA_ADDRESS_P is non-zero, and @@ -111,12 +257,12 @@ struct lwp_info or to a local variable in lin_lwp_wait. */ struct target_waitstatus waitstatus; - /* Signal wether we are in a SYSCALL_ENTRY or + /* Signal whether we are in a SYSCALL_ENTRY or in a SYSCALL_RETURN event. Values: - TARGET_WAITKIND_SYSCALL_ENTRY - TARGET_WAITKIND_SYSCALL_RETURN */ - int syscall_state; + enum target_waitkind syscall_state; /* The processor core this LWP was last seen on. */ int core; @@ -124,7 +270,9 @@ struct lwp_info /* Arch-specific additions. */ struct arch_lwp_info *arch_private; - /* Next LWP in list. */ + /* Previous and next pointers in doubly-linked list of known LWPs, + sorted by reverse creation order. */ + struct lwp_info *prev; struct lwp_info *next; }; @@ -133,6 +281,9 @@ struct lwp_info native target is active. */ extern struct lwp_info *lwp_list; +/* Does the current host support PTRACE_GETREGSET? */ +extern enum tribool have_ptrace_getregset; + /* Iterate over each active thread (light-weight process). */ #define ALL_LWPS(LP) \ for ((LP) = lwp_list; \ @@ -156,9 +307,7 @@ extern void lin_thread_get_thread_signals (sigset_t *mask); void linux_proc_pending_signals (int pid, sigset_t *pending, sigset_t *blocked, sigset_t *ignored); -extern int lin_lwp_attach_lwp (ptid_t ptid); - -extern void linux_stop_lwp (struct lwp_info *lwp); +/* For linux_stop_lwp see nat/linux-nat.h. */ /* Stop all LWPs, synchronously. (Any events that trigger while LWPs are being stopped are left pending.) */ @@ -169,58 +318,6 @@ extern void linux_stop_and_wait_all_lwps (void); left stopped.) */ extern void linux_unstop_all_lwps (void); -/* Iterator function for lin-lwp's lwp list. */ -struct lwp_info *iterate_over_lwps (ptid_t filter, - int (*callback) (struct lwp_info *, - void *), - void *data); - -/* Create a prototype generic GNU/Linux target. The client can - override it with local methods. */ -struct target_ops * linux_target (void); - -/* Create a generic GNU/Linux target using traditional - ptrace register access. */ -struct target_ops * -linux_trad_target (CORE_ADDR (*register_u_offset)(struct gdbarch *, int, int)); - -/* Register the customized GNU/Linux target. This should be used - instead of calling add_target directly. */ -void linux_nat_add_target (struct target_ops *); - -/* Register a method to call whenever a new thread is attached. */ -void linux_nat_set_new_thread (struct target_ops *, void (*) (struct lwp_info *)); - - -/* Register a method to call whenever a new fork is attached. */ -typedef void (linux_nat_new_fork_ftype) (struct lwp_info *parent, - pid_t child_pid); -void linux_nat_set_new_fork (struct target_ops *ops, - linux_nat_new_fork_ftype *fn); - -/* Register a method to call whenever a process is killed or - detached. */ -typedef void (linux_nat_forget_process_ftype) (pid_t pid); -void linux_nat_set_forget_process (struct target_ops *ops, - linux_nat_forget_process_ftype *fn); - -/* Call the method registered with the function above. PID is the - process to forget about. */ -void linux_nat_forget_process (pid_t pid); - -/* Register a method that converts a siginfo object between the layout - that ptrace returns, and the layout in the architecture of the - inferior. */ -void linux_nat_set_siginfo_fixup (struct target_ops *, - int (*) (siginfo_t *, - gdb_byte *, - int)); - -/* Register a method to call prior to resuming a thread. */ - -void linux_nat_set_prepare_to_resume (struct target_ops *, - void (*) (struct lwp_info *)); - /* Update linux-nat internal state when changing from one fork to another. */ void linux_nat_switch_fork (ptid_t new_ptid); @@ -230,6 +327,4 @@ void linux_nat_switch_fork (ptid_t new_ptid); uninitialized in such case). */ int linux_nat_get_siginfo (ptid_t ptid, siginfo_t *siginfo); -/* Set alternative SIGTRAP-like events recognizer. */ -void linux_nat_set_status_is_event (struct target_ops *t, - int (*status_is_event) (int status)); +#endif /* LINUX_NAT_H */