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