linux-nat.h revision 1.3
1 /* Native debugging support for GNU/Linux (LWP layer). 2 3 Copyright (C) 2000-2015 Free Software Foundation, Inc. 4 5 This file is part of GDB. 6 7 This program is free software; you can redistribute it and/or modify 8 it under the terms of the GNU General Public License as published by 9 the Free Software Foundation; either version 3 of the License, or 10 (at your option) any later version. 11 12 This program is distributed in the hope that it will be useful, 13 but WITHOUT ANY WARRANTY; without even the implied warranty of 14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 GNU General Public License for more details. 16 17 You should have received a copy of the GNU General Public License 18 along with this program. If not, see <http://www.gnu.org/licenses/>. */ 19 20 #include "target.h" 21 22 #include <signal.h> 23 24 struct arch_lwp_info; 25 26 /* Reasons an LWP last stopped. */ 27 28 enum lwp_stop_reason 29 { 30 /* Either not stopped, or stopped for a reason that doesn't require 31 special tracking. */ 32 LWP_STOPPED_BY_NO_REASON, 33 34 /* Stopped by a software breakpoint. */ 35 LWP_STOPPED_BY_SW_BREAKPOINT, 36 37 /* Stopped by a hardware breakpoint. */ 38 LWP_STOPPED_BY_HW_BREAKPOINT, 39 40 /* Stopped by a watchpoint. */ 41 LWP_STOPPED_BY_WATCHPOINT 42 }; 43 44 /* Structure describing an LWP. This is public only for the purposes 45 of ALL_LWPS; target-specific code should generally not access it 46 directly. */ 47 48 struct lwp_info 49 { 50 /* The process id of the LWP. This is a combination of the LWP id 51 and overall process id. */ 52 ptid_t ptid; 53 54 /* If this flag is set, we need to set the event request flags the 55 next time we see this LWP stop. */ 56 int must_set_ptrace_flags; 57 58 /* Non-zero if this LWP is cloned. In this context "cloned" means 59 that the LWP is reporting to its parent using a signal other than 60 SIGCHLD. */ 61 int cloned; 62 63 /* Non-zero if we sent this LWP a SIGSTOP (but the LWP didn't report 64 it back yet). */ 65 int signalled; 66 67 /* Non-zero if this LWP is stopped. */ 68 int stopped; 69 70 /* Non-zero if this LWP will be/has been resumed. Note that an LWP 71 can be marked both as stopped and resumed at the same time. This 72 happens if we try to resume an LWP that has a wait status 73 pending. We shouldn't let the LWP run until that wait status has 74 been processed, but we should not report that wait status if GDB 75 didn't try to let the LWP run. */ 76 int resumed; 77 78 /* The last resume GDB requested on this thread. */ 79 enum resume_kind last_resume_kind; 80 81 /* If non-zero, a pending wait status. */ 82 int status; 83 84 /* When 'stopped' is set, this is where the lwp last stopped, with 85 decr_pc_after_break already accounted for. If the LWP is 86 running, and stepping, this is the address at which the lwp was 87 resumed (that is, it's the previous stop PC). If the LWP is 88 running and not stepping, this is 0. */ 89 CORE_ADDR stop_pc; 90 91 /* Non-zero if we were stepping this LWP. */ 92 int step; 93 94 /* The reason the LWP last stopped, if we need to track it 95 (breakpoint, watchpoint, etc.) */ 96 enum lwp_stop_reason stop_reason; 97 98 /* On architectures where it is possible to know the data address of 99 a triggered watchpoint, STOPPED_DATA_ADDRESS_P is non-zero, and 100 STOPPED_DATA_ADDRESS contains such data address. Otherwise, 101 STOPPED_DATA_ADDRESS_P is false, and STOPPED_DATA_ADDRESS is 102 undefined. Only valid if STOPPED_BY_WATCHPOINT is true. */ 103 int stopped_data_address_p; 104 CORE_ADDR stopped_data_address; 105 106 /* Non-zero if we expect a duplicated SIGINT. */ 107 int ignore_sigint; 108 109 /* If WAITSTATUS->KIND != TARGET_WAITKIND_SPURIOUS, the waitstatus 110 for this LWP's last event. This may correspond to STATUS above, 111 or to a local variable in lin_lwp_wait. */ 112 struct target_waitstatus waitstatus; 113 114 /* Signal wether we are in a SYSCALL_ENTRY or 115 in a SYSCALL_RETURN event. 116 Values: 117 - TARGET_WAITKIND_SYSCALL_ENTRY 118 - TARGET_WAITKIND_SYSCALL_RETURN */ 119 int syscall_state; 120 121 /* The processor core this LWP was last seen on. */ 122 int core; 123 124 /* Arch-specific additions. */ 125 struct arch_lwp_info *arch_private; 126 127 /* Next LWP in list. */ 128 struct lwp_info *next; 129 }; 130 131 /* The global list of LWPs, for ALL_LWPS. Unlike the threads list, 132 there is always at least one LWP on the list while the GNU/Linux 133 native target is active. */ 134 extern struct lwp_info *lwp_list; 135 136 /* Iterate over each active thread (light-weight process). */ 137 #define ALL_LWPS(LP) \ 138 for ((LP) = lwp_list; \ 139 (LP) != NULL; \ 140 (LP) = (LP)->next) 141 142 /* Attempt to initialize libthread_db. */ 143 void check_for_thread_db (void); 144 145 int thread_db_attach_lwp (ptid_t ptid); 146 147 /* Return the set of signals used by the threads library. */ 148 extern void lin_thread_get_thread_signals (sigset_t *mask); 149 150 /* Find process PID's pending signal set from /proc/pid/status. */ 151 void linux_proc_pending_signals (int pid, sigset_t *pending, 152 sigset_t *blocked, sigset_t *ignored); 153 154 extern int lin_lwp_attach_lwp (ptid_t ptid); 155 156 extern void linux_stop_lwp (struct lwp_info *lwp); 157 158 /* Iterator function for lin-lwp's lwp list. */ 159 struct lwp_info *iterate_over_lwps (ptid_t filter, 160 int (*callback) (struct lwp_info *, 161 void *), 162 void *data); 163 164 /* Create a prototype generic GNU/Linux target. The client can 165 override it with local methods. */ 166 struct target_ops * linux_target (void); 167 168 /* Create a generic GNU/Linux target using traditional 169 ptrace register access. */ 170 struct target_ops * 171 linux_trad_target (CORE_ADDR (*register_u_offset)(struct gdbarch *, int, int)); 172 173 /* Register the customized GNU/Linux target. This should be used 174 instead of calling add_target directly. */ 175 void linux_nat_add_target (struct target_ops *); 176 177 /* Register a method to call whenever a new thread is attached. */ 178 void linux_nat_set_new_thread (struct target_ops *, void (*) (struct lwp_info *)); 179 180 181 /* Register a method to call whenever a new fork is attached. */ 182 typedef void (linux_nat_new_fork_ftype) (struct lwp_info *parent, 183 pid_t child_pid); 184 void linux_nat_set_new_fork (struct target_ops *ops, 185 linux_nat_new_fork_ftype *fn); 186 187 /* Register a method to call whenever a process is killed or 188 detached. */ 189 typedef void (linux_nat_forget_process_ftype) (pid_t pid); 190 void linux_nat_set_forget_process (struct target_ops *ops, 191 linux_nat_forget_process_ftype *fn); 192 193 /* Call the method registered with the function above. PID is the 194 process to forget about. */ 195 void linux_nat_forget_process (pid_t pid); 196 197 /* Register a method that converts a siginfo object between the layout 198 that ptrace returns, and the layout in the architecture of the 199 inferior. */ 200 void linux_nat_set_siginfo_fixup (struct target_ops *, 201 int (*) (siginfo_t *, 202 gdb_byte *, 203 int)); 204 205 /* Register a method to call prior to resuming a thread. */ 206 207 void linux_nat_set_prepare_to_resume (struct target_ops *, 208 void (*) (struct lwp_info *)); 209 210 /* Update linux-nat internal state when changing from one fork 211 to another. */ 212 void linux_nat_switch_fork (ptid_t new_ptid); 213 214 /* Store the saved siginfo associated with PTID in *SIGINFO. 215 Return 1 if it was retrieved successfully, 0 otherwise (*SIGINFO is 216 uninitialized in such case). */ 217 int linux_nat_get_siginfo (ptid_t ptid, siginfo_t *siginfo); 218 219 /* Set alternative SIGTRAP-like events recognizer. */ 220 void linux_nat_set_status_is_event (struct target_ops *t, 221 int (*status_is_event) (int status)); 222
Indexes created Sun Apr 19 00:22:55 UTC 2026