X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=gdb%2Flinux-nat.h;h=0c1695ad1020aa176752e6bb8e877bf815e63077;hb=98f9338a584c5f68595fc97e692e83f700c8da3d;hp=33727d64fa4e2a4f551253048e95d8ff13280ffc;hpb=7b50312ad68f7c3acac2b318f6ff96956ad381ea;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/linux-nat.h b/gdb/linux-nat.h index 33727d64fa..0c1695ad10 100644 --- a/gdb/linux-nat.h +++ b/gdb/linux-nat.h @@ -1,7 +1,6 @@ /* Native debugging support for GNU/Linux (LWP layer). - Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, - 2010, 2011 Free Software Foundation, Inc. + Copyright (C) 2000-2019 Free Software Foundation, Inc. This file is part of GDB. @@ -18,26 +17,180 @@ 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; - -/* Ways to "resume" a thread. */ +/* A prototype generic GNU/Linux target. A concrete instance should + override it with local methods. */ -enum resume_kind +class linux_nat_target : public inf_ptrace_target { - /* Thread should continue. */ - resume_continue, +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; + + 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; - /* Thread should single-step. */ - resume_step, + int fileio_unlink (struct inferior *inf, + const char *filename, + int *target_errno) override; - /* Thread should be stopped. */ - resume_stop + int insert_fork_catchpoint (int) override; + int remove_fork_catchpoint (int) override; + int insert_vfork_catchpoint (int) override; + int remove_vfork_catchpoint (int) override; + + int insert_exec_catchpoint (int) override; + int remove_exec_catchpoint (int) override; + + 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. */ @@ -48,10 +201,9 @@ struct lwp_info and overall process id. */ ptid_t ptid; - /* 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; + /* If this flag is set, we need to set the event request flags the + next time we see this LWP stop. */ + int must_set_ptrace_flags; /* Non-zero if we sent this LWP a SIGSTOP (but the LWP didn't report it back yet). */ @@ -74,16 +226,19 @@ struct lwp_info /* If non-zero, a pending wait status. */ int status; + /* When 'stopped' is set, this is where the lwp last stopped, with + decr_pc_after_break already accounted for. If the LWP is + running, and stepping, this is the address at which the lwp was + resumed (that is, it's the previous stop PC). If the LWP is + running and not stepping, this is 0. */ + CORE_ADDR stop_pc; + /* Non-zero if we were stepping this LWP. */ int step; - /* Non-zero si_signo if this LWP stopped with a trap. si_addr may - be the address of a hardware watchpoint. */ - struct siginfo siginfo; - - /* STOPPED_BY_WATCHPOINT is non-zero if this LWP stopped with a data - watchpoint trap. */ - int stopped_by_watchpoint; + /* The reason the LWP last stopped, if we need to track it + (breakpoint, watchpoint, etc.) */ + 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 @@ -101,12 +256,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; @@ -114,7 +269,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; }; @@ -123,21 +280,24 @@ 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; \ (LP) != NULL; \ (LP) = (LP)->next) -#define GET_LWP(ptid) ptid_get_lwp (ptid) -#define GET_PID(ptid) ptid_get_pid (ptid) -#define is_lwp(ptid) (GET_LWP (ptid) != 0) -#define BUILD_LWP(lwp, pid) ptid_build (pid, lwp, 0) - /* Attempt to initialize libthread_db. */ void check_for_thread_db (void); -int thread_db_attach_lwp (ptid_t ptid); +/* Called from the LWP layer to inform the thread_db layer that PARENT + spawned CHILD. Both LWPs are currently stopped. This function + does whatever is required to have the child LWP under the + thread_db's control --- e.g., enabling event reporting. Returns + true on success, false if the process isn't using libpthread. */ +extern int thread_db_notice_clone (ptid_t parent, ptid_t child); /* Return the set of signals used by the threads library. */ extern void lin_thread_get_thread_signals (sigset_t *mask); @@ -146,58 +306,24 @@ 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); -/* linux-nat functions for handling fork events. */ -extern void linux_enable_event_reporting (ptid_t ptid); +/* For linux_stop_lwp see nat/linux-nat.h. */ -extern int lin_lwp_attach_lwp (ptid_t ptid); +/* Stop all LWPs, synchronously. (Any events that trigger while LWPs + are being stopped are left pending.) */ +extern void linux_stop_and_wait_all_lwps (void); -extern void linux_stop_lwp (struct lwp_info *lwp); - -/* 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 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 (*) (struct siginfo *, - 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 *)); +/* Set resumed LWPs running again, as they were before being stopped + with linux_stop_and_wait_all_lwps. (LWPS with pending events are + left stopped.) */ +extern void linux_unstop_all_lwps (void); /* Update linux-nat internal state when changing from one fork to another. */ void linux_nat_switch_fork (ptid_t new_ptid); -/* Return the saved siginfo associated with PTID. */ -struct siginfo *linux_nat_get_siginfo (ptid_t ptid); - -/* Compute and return the processor core of a given thread. */ -int linux_nat_core_of_thread_1 (ptid_t ptid); +/* Store the saved siginfo associated with PTID in *SIGINFO. + Return 1 if it was retrieved successfully, 0 otherwise (*SIGINFO is + 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 */