gdbserver/inferiors.cc

   1 /* Inferior process information for the remote server for GDB.
   2    Copyright (C) 2002-2020 Free Software Foundation, Inc.
   3
   4    Contributed by MontaVista Software.
   5
   6    This file is part of GDB.
   7
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 3 of the License, or
  11    (at your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  20
  21 #include "server.h"
  22 #include "gdbsupport/common-inferior.h"
  23 #include "gdbthread.h"
  24 #include "dll.h"
  25
  26 std::list<process_info *> all_processes;
  27 std::list<thread_info *> all_threads;
  28
  29 struct thread_info *current_thread;
  30
  31 /* The current working directory used to start the inferior.  */
  32 static const char *current_inferior_cwd = NULL;
  33
  34 struct thread_info *
  35 add_thread (ptid_t thread_id, void *target_data)
  36 {
  37   struct thread_info *new_thread = XCNEW (struct thread_info);
  38
  39   new_thread->id = thread_id;
  40   new_thread->last_resume_kind = resume_continue;
  41   new_thread->last_status.kind = TARGET_WAITKIND_IGNORE;
  42
  43   all_threads.push_back (new_thread);
  44
  45   if (current_thread == NULL)
  46     current_thread = new_thread;
  47
  48   new_thread->target_data = target_data;
  49
  50   return new_thread;
  51 }
  52
  53 /* See gdbthread.h.  */
  54
  55 struct thread_info *
  56 get_first_thread (void)
  57 {
  58   if (!all_threads.empty ())
  59     return all_threads.front ();
  60   else
  61     return NULL;
  62 }
  63
  64 struct thread_info *
  65 find_thread_ptid (ptid_t ptid)
  66 {
  67   return find_thread ([&] (thread_info *thread) {
  68     return thread->id == ptid;
  69   });
  70 }
  71
  72 /* Find a thread associated with the given PROCESS, or NULL if no
  73    such thread exists.  */
  74
  75 static struct thread_info *
  76 find_thread_process (const struct process_info *const process)
  77 {
  78   return find_any_thread_of_pid (process->pid);
  79 }
  80
  81 /* See gdbthread.h.  */
  82
  83 struct thread_info *
  84 find_any_thread_of_pid (int pid)
  85 {
  86   return find_thread (pid, [] (thread_info *thread) {
  87     return true;
  88   });
  89 }
  90
  91 static void
  92 free_one_thread (thread_info *thread)
  93 {
  94   free_register_cache (thread_regcache_data (thread));
  95   free (thread);
  96 }
  97
  98 void
  99 remove_thread (struct thread_info *thread)
 100 {
 101   if (thread->btrace != NULL)
 102     target_disable_btrace (thread->btrace);
 103
 104   discard_queued_stop_replies (ptid_of (thread));
 105   all_threads.remove (thread);
 106   if (current_thread == thread)
 107     current_thread = NULL;
 108   free_one_thread (thread);
 109 }
 110
 111 void *
 112 thread_target_data (struct thread_info *thread)
 113 {
 114   return thread->target_data;
 115 }
 116
 117 struct regcache *
 118 thread_regcache_data (struct thread_info *thread)
 119 {
 120   return thread->regcache_data;
 121 }
 122
 123 void
 124 set_thread_regcache_data (struct thread_info *thread, struct regcache *data)
 125 {
 126   thread->regcache_data = data;
 127 }
 128
 129 void
 130 clear_inferiors (void)
 131 {
 132   for_each_thread (free_one_thread);
 133   all_threads.clear ();
 134
 135   clear_dlls ();
 136
 137   current_thread = NULL;
 138 }
 139
 140 struct process_info *
 141 add_process (int pid, int attached)
 142 {
 143   process_info *process = new process_info (pid, attached);
 144
 145   all_processes.push_back (process);
 146
 147   return process;
 148 }
 149
 150 /* Remove a process from the common process list and free the memory
 151    allocated for it.
 152    The caller is responsible for freeing private data first.  */
 153
 154 void
 155 remove_process (struct process_info *process)
 156 {
 157   clear_symbol_cache (&process->symbol_cache);
 158   free_all_breakpoints (process);
 159   gdb_assert (find_thread_process (process) == NULL);
 160   all_processes.remove (process);
 161   delete process;
 162 }
 163
 164 process_info *
 165 find_process_pid (int pid)
 166 {
 167   return find_process ([&] (process_info *process) {
 168     return process->pid == pid;
 169   });
 170 }
 171
 172 /* Get the first process in the process list, or NULL if the list is empty.  */
 173
 174 process_info *
 175 get_first_process (void)
 176 {
 177   if (!all_processes.empty ())
 178     return all_processes.front ();
 179   else
 180     return NULL;
 181 }
 182
 183 /* Return non-zero if there are any inferiors that we have created
 184    (as opposed to attached-to).  */
 185
 186 int
 187 have_started_inferiors_p (void)
 188 {
 189   return find_process ([] (process_info *process) {
 190     return !process->attached;
 191   }) != NULL;
 192 }
 193
 194 /* Return non-zero if there are any inferiors that we have attached to.  */
 195
 196 int
 197 have_attached_inferiors_p (void)
 198 {
 199   return find_process ([] (process_info *process) {
 200     return process->attached;
 201   }) != NULL;
 202 }
 203
 204 struct process_info *
 205 get_thread_process (const struct thread_info *thread)
 206 {
 207   return find_process_pid (thread->id.pid ());
 208 }
 209
 210 struct process_info *
 211 current_process (void)
 212 {
 213   gdb_assert (current_thread != NULL);
 214   return get_thread_process (current_thread);
 215 }
 216
 217 /* See gdbsupport/common-gdbthread.h.  */
 218
 219 void
 220 switch_to_thread (process_stratum_target *ops, ptid_t ptid)
 221 {
 222   gdb_assert (ptid != minus_one_ptid);
 223   current_thread = find_thread_ptid (ptid);
 224 }
 225
 226 /* See inferiors.h.  */
 227
 228 void
 229 switch_to_process (process_info *proc)
 230 {
 231   int pid = pid_of (proc);
 232
 233   current_thread = find_any_thread_of_pid (pid);
 234 }
 235
 236 /* See gdbsupport/common-inferior.h.  */
 237
 238 const char *
 239 get_inferior_cwd ()
 240 {
 241   return current_inferior_cwd;
 242 }
 243
 244 /* See gdbsupport/common-inferior.h.  */
 245
 246 void
 247 set_inferior_cwd (const char *cwd)
 248 {
 249   xfree ((void *) current_inferior_cwd);
 250   if (cwd != NULL)
 251     current_inferior_cwd = xstrdup (cwd);
 252   else
 253     current_inferior_cwd = NULL;
 254 }