gdbserver/gdbthread.h

   1 /* Multi-thread control defs for remote server for GDB.
   2    Copyright (C) 1993-2023 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
  27 struct btrace_target_info;
  28 struct regcache;
  29
  30 struct thread_info
  31 {
  32   thread_info (ptid_t id, void *target_data)
  33     : id (id), target_data (target_data)
  34   {}
  35
  36   ~thread_info ()
  37   {
  38     free_register_cache (this->regcache_data);
  39   }
  40
  41   /* The id of this thread.  */
  42   ptid_t id;
  43
  44   void *target_data;
  45   struct regcache *regcache_data = nullptr;
  46
  47   /* The last resume GDB requested on this thread.  */
  48   enum resume_kind last_resume_kind = resume_continue;
  49
  50   /* The last wait status reported for this thread.  */
  51   struct target_waitstatus last_status;
  52
  53   /* True if LAST_STATUS hasn't been reported to GDB yet.  */
  54   int status_pending_p = 0;
  55
  56   /* Given `while-stepping', a thread may be collecting data for more
  57      than one tracepoint simultaneously.  E.g.:
  58
  59     ff0001  INSN1 <-- TP1, while-stepping 10 collect $regs
  60     ff0002  INSN2
  61     ff0003  INSN3 <-- TP2, collect $regs
  62     ff0004  INSN4 <-- TP3, while-stepping 10 collect $regs
  63     ff0005  INSN5
  64
  65    Notice that when instruction INSN5 is reached, the while-stepping
  66    actions of both TP1 and TP3 are still being collected, and that TP2
  67    had been collected meanwhile.  The whole range of ff0001-ff0005
  68    should be single-stepped, due to at least TP1's while-stepping
  69    action covering the whole range.
  70
  71    On the other hand, the same tracepoint with a while-stepping action
  72    may be hit by more than one thread simultaneously, hence we can't
  73    keep the current step count in the tracepoint itself.
  74
  75    This is the head of the list of the states of `while-stepping'
  76    tracepoint actions this thread is now collecting; NULL if empty.
  77    Each item in the list holds the current step of the while-stepping
  78    action.  */
  79   struct wstep_state *while_stepping = nullptr;
  80
  81   /* Branch trace target information for this thread.  */
  82   struct btrace_target_info *btrace = nullptr;
  83
  84   /* Thread options GDB requested with QThreadOptions.  */
  85   gdb_thread_options thread_options = 0;
  86 };
  87
  88 extern std::list<thread_info *> all_threads;
  89
  90 void remove_thread (struct thread_info *thread);
  91 struct thread_info *add_thread (ptid_t ptid, void *target_data);
  92
  93 /* Return a pointer to the first thread, or NULL if there isn't one.  */
  94
  95 struct thread_info *get_first_thread (void);
  96
  97 struct thread_info *find_thread_ptid (ptid_t ptid);
  98
  99 /* Find any thread of the PID process.  Returns NULL if none is
 100    found.  */
 101 struct thread_info *find_any_thread_of_pid (int pid);
 102
 103 /* Find the first thread for which FUNC returns true.  Return NULL if no thread
 104    satisfying FUNC is found.  */
 105
 106 template <typename Func>
 107 static thread_info *
 108 find_thread (Func func)
 109 {
 110   std::list<thread_info *>::iterator next, cur = all_threads.begin ();
 111
 112   while (cur != all_threads.end ())
 113     {
 114       next = cur;
 115       next++;
 116
 117       if (func (*cur))
 118         return *cur;
 119
 120       cur = next;
 121     }
 122
 123   return NULL;
 124 }
 125
 126 /* Like the above, but only consider threads with pid PID.  */
 127
 128 template <typename Func>
 129 static thread_info *
 130 find_thread (int pid, Func func)
 131 {
 132   return find_thread ([&] (thread_info *thread)
 133     {
 134       return thread->id.pid () == pid && func (thread);
 135     });
 136 }
 137
 138 /* Find the first thread that matches FILTER for which FUNC returns true.
 139    Return NULL if no thread satisfying these conditions is found.  */
 140
 141 template <typename Func>
 142 static thread_info *
 143 find_thread (ptid_t filter, Func func)
 144 {
 145   return find_thread ([&] (thread_info *thread) {
 146     return thread->id.matches (filter) && func (thread);
 147   });
 148 }
 149
 150 /* Invoke FUNC for each thread.  */
 151
 152 template <typename Func>
 153 static void
 154 for_each_thread (Func func)
 155 {
 156   std::list<thread_info *>::iterator next, cur = all_threads.begin ();
 157
 158   while (cur != all_threads.end ())
 159     {
 160       next = cur;
 161       next++;
 162       func (*cur);
 163       cur = next;
 164     }
 165 }
 166
 167 /* Like the above, but only consider threads with pid PID.  */
 168
 169 template <typename Func>
 170 static void
 171 for_each_thread (int pid, Func func)
 172 {
 173   for_each_thread ([&] (thread_info *thread)
 174     {
 175       if (pid == thread->id.pid ())
 176         func (thread);
 177     });
 178 }
 179
 180 /* Find the a random thread for which FUNC (THREAD) returns true.  If
 181    no entry is found then return NULL.  */
 182
 183 template <typename Func>
 184 static thread_info *
 185 find_thread_in_random (Func func)
 186 {
 187   int count = 0;
 188   int random_selector;
 189
 190   /* First count how many interesting entries we have.  */
 191   for_each_thread ([&] (thread_info *thread) {
 192     if (func (thread))
 193       count++;
 194   });
 195
 196   if (count == 0)
 197     return NULL;
 198
 199   /* Now randomly pick an entry out of those.  */
 200   random_selector = (int)
 201     ((count * (double) rand ()) / (RAND_MAX + 1.0));
 202
 203   thread_info *thread = find_thread ([&] (thread_info *thr_arg) {
 204     return func (thr_arg) && (random_selector-- == 0);
 205   });
 206
 207   gdb_assert (thread != NULL);
 208
 209   return thread;
 210 }
 211
 212 /* Get current thread ID (Linux task ID).  */
 213 #define current_ptid (current_thread->id)
 214
 215 /* Get the ptid of THREAD.  */
 216
 217 static inline ptid_t
 218 ptid_of (const thread_info *thread)
 219 {
 220   return thread->id;
 221 }
 222
 223 /* Get the pid of THREAD.  */
 224
 225 static inline int
 226 pid_of (const thread_info *thread)
 227 {
 228   return thread->id.pid ();
 229 }
 230
 231 /* Get the lwp of THREAD.  */
 232
 233 static inline long
 234 lwpid_of (const thread_info *thread)
 235 {
 236   return thread->id.lwp ();
 237 }
 238
 239 /* Switch the current thread.  */
 240
 241 void switch_to_thread (thread_info *thread);
 242
 243 /* Save/restore current thread.  */
 244
 245 class scoped_restore_current_thread
 246 {
 247 public:
 248   scoped_restore_current_thread ();
 249   ~scoped_restore_current_thread ();
 250
 251   DISABLE_COPY_AND_ASSIGN (scoped_restore_current_thread);
 252
 253   /* Cancel restoring on scope exit.  */
 254   void dont_restore () { m_dont_restore = true; }
 255
 256 private:
 257   bool m_dont_restore = false;
 258   process_info *m_process;
 259   thread_info *m_thread;
 260 };
 261
 262 #endif /* GDBSERVER_GDBTHREAD_H */