1 /* Native debugging support for GNU/Linux (LWP layer). 2 3 Copyright (C) 2000-2020 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 #ifndef LINUX_NAT_H 21 #define LINUX_NAT_H 22 23 #include "nat/linux-nat.h" 24 #include "inf-ptrace.h" 25 #include "target.h" 26 #include <signal.h> 27 28 /* A prototype generic GNU/Linux target. A concrete instance should 29 override it with local methods. */ 30 31 class linux_nat_target : public inf_ptrace_target 32 { 33 public: 34 linux_nat_target (); 35 ~linux_nat_target () override = 0; 36 37 thread_control_capabilities get_thread_control_capabilities () override 38 { return tc_schedlock; } 39 40 void create_inferior (const char *, const std::string &, 41 char **, int) override; 42 43 void attach (const char *, int) override; 44 45 void detach (inferior *, int) override; 46 47 void resume (ptid_t, int, enum gdb_signal) override; 48 49 ptid_t wait (ptid_t, struct target_waitstatus *, int) override; 50 51 void pass_signals (gdb::array_view<const unsigned char>) override; 52 53 enum target_xfer_status xfer_partial (enum target_object object, 54 const char *annex, 55 gdb_byte *readbuf, 56 const gdb_byte *writebuf, 57 ULONGEST offset, ULONGEST len, 58 ULONGEST *xfered_len) override; 59 60 void kill () override; 61 62 void mourn_inferior () override; 63 bool thread_alive (ptid_t ptid) override; 64 65 void update_thread_list () override; 66 67 std::string pid_to_str (ptid_t) override; 68 69 const char *thread_name (struct thread_info *) override; 70 71 struct address_space *thread_address_space (ptid_t) override; 72 73 bool stopped_by_watchpoint () override; 74 75 bool stopped_data_address (CORE_ADDR *) override; 76 77 bool stopped_by_sw_breakpoint () override; 78 bool supports_stopped_by_sw_breakpoint () override; 79 80 bool stopped_by_hw_breakpoint () override; 81 bool supports_stopped_by_hw_breakpoint () override; 82 83 void thread_events (int) override; 84 85 bool can_async_p () override; 86 bool is_async_p () override; 87 88 bool supports_non_stop () override; 89 bool always_non_stop_p () override; 90 91 int async_wait_fd () override; 92 void async (int) override; 93 94 void close () override; 95 96 void stop (ptid_t) override; 97 98 bool supports_multi_process () override; 99 100 bool supports_disable_randomization () override; 101 102 int core_of_thread (ptid_t ptid) override; 103 104 bool filesystem_is_local () override; 105 106 int fileio_open (struct inferior *inf, const char *filename, 107 int flags, int mode, int warn_if_slow, 108 int *target_errno) override; 109 110 gdb::optional<std::string> 111 fileio_readlink (struct inferior *inf, 112 const char *filename, 113 int *target_errno) override; 114 115 int fileio_unlink (struct inferior *inf, 116 const char *filename, 117 int *target_errno) override; 118 119 int insert_fork_catchpoint (int) override; 120 int remove_fork_catchpoint (int) override; 121 int insert_vfork_catchpoint (int) override; 122 int remove_vfork_catchpoint (int) override; 123 124 int insert_exec_catchpoint (int) override; 125 int remove_exec_catchpoint (int) override; 126 127 int set_syscall_catchpoint (int pid, bool needed, int any_count, 128 gdb::array_view<const int> syscall_counts) override; 129 130 char *pid_to_exec_file (int pid) override; 131 132 void post_startup_inferior (ptid_t) override; 133 134 void post_attach (int) override; 135 136 bool follow_fork (bool, bool) override; 137 138 std::vector<static_tracepoint_marker> 139 static_tracepoint_markers_by_strid (const char *id) override; 140 141 /* Methods that are meant to overridden by the concrete 142 arch-specific target instance. */ 143 144 virtual void low_resume (ptid_t ptid, int step, enum gdb_signal sig) 145 { inf_ptrace_target::resume (ptid, step, sig); } 146 147 virtual bool low_stopped_by_watchpoint () 148 { return false; } 149 150 virtual bool low_stopped_data_address (CORE_ADDR *addr_p) 151 { return false; } 152 153 /* The method to call, if any, when a new thread is attached. */ 154 virtual void low_new_thread (struct lwp_info *) 155 {} 156 157 /* The method to call, if any, when a thread is destroyed. */ 158 virtual void low_delete_thread (struct arch_lwp_info *lp) 159 { 160 gdb_assert (lp == NULL); 161 } 162 163 /* The method to call, if any, when a new fork is attached. */ 164 virtual void low_new_fork (struct lwp_info *parent, pid_t child_pid) 165 {} 166 167 /* The method to call, if any, when a new clone event is detected. */ 168 virtual void low_new_clone (struct lwp_info *parent, pid_t child_lwp) 169 {} 170 171 /* The method to call, if any, when a process is no longer 172 attached. */ 173 virtual void low_forget_process (pid_t pid) 174 {} 175 176 /* Hook to call prior to resuming a thread. */ 177 virtual void low_prepare_to_resume (struct lwp_info *) 178 {} 179 180 /* Convert a ptrace/host siginfo object, into/from the siginfo in 181 the layout of the inferiors' architecture. Returns true if any 182 conversion was done; false otherwise, in which case the caller 183 does a straight memcpy. If DIRECTION is 1, then copy from INF to 184 PTRACE. If DIRECTION is 0, copy from PTRACE to INF. */ 185 virtual bool low_siginfo_fixup (siginfo_t *ptrace, gdb_byte *inf, 186 int direction) 187 { return false; } 188 189 /* SIGTRAP-like breakpoint status events recognizer. The default 190 recognizes SIGTRAP only. */ 191 virtual bool low_status_is_event (int status); 192 }; 193 194 /* The final/concrete instance. */ 195 extern linux_nat_target *linux_target; 196 197 struct arch_lwp_info; 198 199 /* Structure describing an LWP. This is public only for the purposes 200 of ALL_LWPS; target-specific code should generally not access it 201 directly. */ 202 203 struct lwp_info 204 { 205 /* The process id of the LWP. This is a combination of the LWP id 206 and overall process id. */ 207 ptid_t ptid; 208 209 /* If this flag is set, we need to set the event request flags the 210 next time we see this LWP stop. */ 211 int must_set_ptrace_flags; 212 213 /* Non-zero if we sent this LWP a SIGSTOP (but the LWP didn't report 214 it back yet). */ 215 int signalled; 216 217 /* Non-zero if this LWP is stopped. */ 218 int stopped; 219 220 /* Non-zero if this LWP will be/has been resumed. Note that an LWP 221 can be marked both as stopped and resumed at the same time. This 222 happens if we try to resume an LWP that has a wait status 223 pending. We shouldn't let the LWP run until that wait status has 224 been processed, but we should not report that wait status if GDB 225 didn't try to let the LWP run. */ 226 int resumed; 227 228 /* The last resume GDB requested on this thread. */ 229 enum resume_kind last_resume_kind; 230 231 /* If non-zero, a pending wait status. */ 232 int status; 233 234 /* When 'stopped' is set, this is where the lwp last stopped, with 235 decr_pc_after_break already accounted for. If the LWP is 236 running and stepping, this is the address at which the lwp was 237 resumed (that is, it's the previous stop PC). If the LWP is 238 running and not stepping, this is 0. */ 239 CORE_ADDR stop_pc; 240 241 /* Non-zero if we were stepping this LWP. */ 242 int step; 243 244 /* The reason the LWP last stopped, if we need to track it 245 (breakpoint, watchpoint, etc.). */ 246 enum target_stop_reason stop_reason; 247 248 /* On architectures where it is possible to know the data address of 249 a triggered watchpoint, STOPPED_DATA_ADDRESS_P is non-zero, and 250 STOPPED_DATA_ADDRESS contains such data address. Otherwise, 251 STOPPED_DATA_ADDRESS_P is false, and STOPPED_DATA_ADDRESS is 252 undefined. Only valid if STOPPED_BY_WATCHPOINT is true. */ 253 int stopped_data_address_p; 254 CORE_ADDR stopped_data_address; 255 256 /* Non-zero if we expect a duplicated SIGINT. */ 257 int ignore_sigint; 258 259 /* If WAITSTATUS->KIND != TARGET_WAITKIND_SPURIOUS, the waitstatus 260 for this LWP's last event. This may correspond to STATUS above, 261 or to a local variable in lin_lwp_wait. */ 262 struct target_waitstatus waitstatus; 263 264 /* Signal whether we are in a SYSCALL_ENTRY or 265 in a SYSCALL_RETURN event. 266 Values: 267 - TARGET_WAITKIND_SYSCALL_ENTRY 268 - TARGET_WAITKIND_SYSCALL_RETURN */ 269 enum target_waitkind syscall_state; 270 271 /* The processor core this LWP was last seen on. */ 272 int core; 273 274 /* Arch-specific additions. */ 275 struct arch_lwp_info *arch_private; 276 277 /* Previous and next pointers in doubly-linked list of known LWPs, 278 sorted by reverse creation order. */ 279 struct lwp_info *prev; 280 struct lwp_info *next; 281 }; 282 283 /* The global list of LWPs, for ALL_LWPS. Unlike the threads list, 284 there is always at least one LWP on the list while the GNU/Linux 285 native target is active. */ 286 extern struct lwp_info *lwp_list; 287 288 /* Does the current host support PTRACE_GETREGSET? */ 289 extern enum tribool have_ptrace_getregset; 290 291 /* Iterate over each active thread (light-weight process). */ 292 #define ALL_LWPS(LP) \ 293 for ((LP) = lwp_list; \ 294 (LP) != NULL; \ 295 (LP) = (LP)->next) 296 297 /* Attempt to initialize libthread_db. */ 298 void check_for_thread_db (void); 299 300 /* Called from the LWP layer to inform the thread_db layer that PARENT 301 spawned CHILD. Both LWPs are currently stopped. This function 302 does whatever is required to have the child LWP under the 303 thread_db's control --- e.g., enabling event reporting. Returns 304 true on success, false if the process isn't using libpthread. */ 305 extern int thread_db_notice_clone (ptid_t parent, ptid_t child); 306 307 /* Return the set of signals used by the threads library. */ 308 extern void lin_thread_get_thread_signals (sigset_t *mask); 309 310 /* Find process PID's pending signal set from /proc/pid/status. */ 311 void linux_proc_pending_signals (int pid, sigset_t *pending, 312 sigset_t *blocked, sigset_t *ignored); 313 314 /* For linux_stop_lwp see nat/linux-nat.h. */ 315 316 /* Stop all LWPs, synchronously. (Any events that trigger while LWPs 317 are being stopped are left pending.) */ 318 extern void linux_stop_and_wait_all_lwps (void); 319 320 /* Set resumed LWPs running again, as they were before being stopped 321 with linux_stop_and_wait_all_lwps. (LWPS with pending events are 322 left stopped.) */ 323 extern void linux_unstop_all_lwps (void); 324 325 /* Update linux-nat internal state when changing from one fork 326 to another. */ 327 void linux_nat_switch_fork (ptid_t new_ptid); 328 329 /* Store the saved siginfo associated with PTID in *SIGINFO. 330 Return 1 if it was retrieved successfully, 0 otherwise (*SIGINFO is 331 uninitialized in such case). */ 332 int linux_nat_get_siginfo (ptid_t ptid, siginfo_t *siginfo); 333 334 #endif /* LINUX_NAT_H */ 335