gdbserver/gdbthread.h

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