1/* Multi-thread control defs for remote server for GDB. 2 Copyright (C) 1993-2020 Free Software Foundation, Inc. 3 4 This file is part of GDB. 5 6 This program is free software; you can redistribute it and/or modify 7 it under the terms of the GNU General Public License as published by 8 the Free Software Foundation; either version 3 of the License, or 9 (at your option) any later version. 10 11 This program is distributed in the hope that it will be useful, 12 but WITHOUT ANY WARRANTY; without even the implied warranty of 13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 GNU General Public License for more details. 15 16 You should have received a copy of the GNU General Public License 17 along with this program. If not, see <http://www.gnu.org/licenses/>. */ 18 19#ifndef GDBSERVER_GDBTHREAD_H 20#define GDBSERVER_GDBTHREAD_H 21 22#include "gdbsupport/common-gdbthread.h" 23#include "inferiors.h" 24 25#include <list> 26 27struct btrace_target_info; 28struct regcache; 29 30struct thread_info 31{ 32 /* The id of this thread. */ 33 ptid_t id; 34 35 void *target_data; 36 struct regcache *regcache_data; 37 38 /* The last resume GDB requested on this thread. */ 39 enum resume_kind last_resume_kind; 40 41 /* The last wait status reported for this thread. */ 42 struct target_waitstatus last_status; 43 44 /* True if LAST_STATUS hasn't been reported to GDB yet. */ 45 int status_pending_p; 46 47 /* Given `while-stepping', a thread may be collecting data for more 48 than one tracepoint simultaneously. E.g.: 49 50 ff0001 INSN1 <-- TP1, while-stepping 10 collect $regs 51 ff0002 INSN2 52 ff0003 INSN3 <-- TP2, collect $regs 53 ff0004 INSN4 <-- TP3, while-stepping 10 collect $regs 54 ff0005 INSN5 55 56 Notice that when instruction INSN5 is reached, the while-stepping 57 actions of both TP1 and TP3 are still being collected, and that TP2 58 had been collected meanwhile. The whole range of ff0001-ff0005 59 should be single-stepped, due to at least TP1's while-stepping 60 action covering the whole range. 61 62 On the other hand, the same tracepoint with a while-stepping action 63 may be hit by more than one thread simultaneously, hence we can't 64 keep the current step count in the tracepoint itself. 65 66 This is the head of the list of the states of `while-stepping' 67 tracepoint actions this thread is now collecting; NULL if empty. 68 Each item in the list holds the current step of the while-stepping 69 action. */ 70 struct wstep_state *while_stepping; 71 72 /* Branch trace target information for this thread. */ 73 struct btrace_target_info *btrace; 74}; 75 76extern std::list<thread_info *> all_threads; 77 78void remove_thread (struct thread_info *thread); 79struct thread_info *add_thread (ptid_t ptid, void *target_data); 80 81/* Return a pointer to the first thread, or NULL if there isn't one. */ 82 83struct thread_info *get_first_thread (void); 84 85struct thread_info *find_thread_ptid (ptid_t ptid); 86 87/* Find any thread of the PID process. Returns NULL if none is 88 found. */ 89struct thread_info *find_any_thread_of_pid (int pid); 90 91/* Find the first thread for which FUNC returns true. Return NULL if no thread 92 satisfying FUNC is found. */ 93 94template <typename Func> 95static thread_info * 96find_thread (Func func) 97{ 98 std::list<thread_info *>::iterator next, cur = all_threads.begin (); 99 100 while (cur != all_threads.end ()) 101 { 102 next = cur; 103 next++; 104 105 if (func (*cur)) 106 return *cur; 107 108 cur = next; 109 } 110 111 return NULL; 112} 113 114/* Like the above, but only consider threads with pid PID. */ 115 116template <typename Func> 117static thread_info * 118find_thread (int pid, Func func) 119{ 120 return find_thread ([&] (thread_info *thread) 121 { 122 return thread->id.pid () == pid && func (thread); 123 }); 124} 125 126/* Find the first thread that matches FILTER for which FUNC returns true. 127 Return NULL if no thread satisfying these conditions is found. */ 128 129template <typename Func> 130static thread_info * 131find_thread (ptid_t filter, Func func) 132{ 133 return find_thread ([&] (thread_info *thread) { 134 return thread->id.matches (filter) && func (thread); 135 }); 136} 137 138/* Invoke FUNC for each thread. */ 139 140template <typename Func> 141static void 142for_each_thread (Func func) 143{ 144 std::list<thread_info *>::iterator next, cur = all_threads.begin (); 145 146 while (cur != all_threads.end ()) 147 { 148 next = cur; 149 next++; 150 func (*cur); 151 cur = next; 152 } 153} 154 155/* Like the above, but only consider threads with pid PID. */ 156 157template <typename Func> 158static void 159for_each_thread (int pid, Func func) 160{ 161 for_each_thread ([&] (thread_info *thread) 162 { 163 if (pid == thread->id.pid ()) 164 func (thread); 165 }); 166} 167 168/* Find the a random thread for which FUNC (THREAD) returns true. If 169 no entry is found then return NULL. */ 170 171template <typename Func> 172static thread_info * 173find_thread_in_random (Func func) 174{ 175 int count = 0; 176 int random_selector; 177 178 /* First count how many interesting entries we have. */ 179 for_each_thread ([&] (thread_info *thread) { 180 if (func (thread)) 181 count++; 182 }); 183 184 if (count == 0) 185 return NULL; 186 187 /* Now randomly pick an entry out of those. */ 188 random_selector = (int) 189 ((count * (double) rand ()) / (RAND_MAX + 1.0)); 190 191 thread_info *thread = find_thread ([&] (thread_info *thr_arg) { 192 return func (thr_arg) && (random_selector-- == 0); 193 }); 194 195 gdb_assert (thread != NULL); 196 197 return thread; 198} 199 200/* Get current thread ID (Linux task ID). */ 201#define current_ptid (current_thread->id) 202 203/* Get the ptid of THREAD. */ 204 205static inline ptid_t 206ptid_of (const thread_info *thread) 207{ 208 return thread->id; 209} 210 211/* Get the pid of THREAD. */ 212 213static inline int 214pid_of (const thread_info *thread) 215{ 216 return thread->id.pid (); 217} 218 219/* Get the lwp of THREAD. */ 220 221static inline long 222lwpid_of (const thread_info *thread) 223{ 224 return thread->id.lwp (); 225} 226 227#endif /* GDBSERVER_GDBTHREAD_H */ 228