gdb/gdbserver/inferiors.c

   1 /* Inferior process information for the remote server for GDB.
   2    Copyright (C) 2002-2017 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 "gdbthread.h"
  23 #include "dll.h"
  24
  25 std::list<process_info *> all_processes;
  26 std::list<thread_info *> all_threads;
  27
  28 struct thread_info *current_thread;
  29
  30 /* The current working directory used to start the inferior.  */
  31 static const char *current_inferior_cwd = NULL;
  32
  33 thread_info *
  34 find_inferior (std::list<thread_info *> *thread_list,
  35                int (*func) (thread_info *, void *),
  36                void *arg)
  37 {
  38   gdb_assert (thread_list == &all_threads);
  39
  40   return find_thread ([&] (thread_info *thread) {
  41     return func (thread, arg);
  42   });
  43 }
  44
  45 thread_info *
  46 find_inferior_in_random (std::list<thread_info *> *thread_list,
  47                          int (*func) (thread_info *, void *),
  48                          void *arg)
  49 {
  50   gdb_assert (thread_list == &all_threads);
  51
  52   return find_thread_in_random ([&] (thread_info *thread) {
  53     return func (thread, arg);
  54   });
  55 }
  56
  57 void
  58 for_each_inferior (std::list<thread_info *> *thread_list,
  59                    void (*action) (thread_info *))
  60 {
  61   gdb_assert (thread_list == &all_threads);
  62
  63   for_each_thread ([&] (thread_info *thread) {
  64     action (thread);
  65   });
  66 }
  67
  68 void
  69 for_each_inferior_with_data (std::list<thread_info *> *thread_list,
  70                              void (*action) (thread_info *, void *),
  71                              void *data)
  72 {
  73   gdb_assert (thread_list == &all_threads);
  74
  75   for_each_thread ([&] (thread_info *thread) {
  76     action (thread, data);
  77   });
  78 }
  79
  80 struct thread_info *
  81 add_thread (ptid_t thread_id, void *target_data)
  82 {
  83   struct thread_info *new_thread = XCNEW (struct thread_info);
  84
  85   new_thread->id = thread_id;
  86   new_thread->last_resume_kind = resume_continue;
  87   new_thread->last_status.kind = TARGET_WAITKIND_IGNORE;
  88
  89   all_threads.push_back (new_thread);
  90
  91   if (current_thread == NULL)
  92     current_thread = new_thread;
  93
  94   new_thread->target_data = target_data;
  95
  96   return new_thread;
  97 }
  98
  99 /* See gdbthread.h.  */
 100
 101 struct thread_info *
 102 get_first_thread (void)
 103 {
 104   if (!all_threads.empty ())
 105     return all_threads.front ();
 106   else
 107     return NULL;
 108 }
 109
 110 struct thread_info *
 111 find_thread_ptid (ptid_t ptid)
 112 {
 113   return find_thread ([&] (thread_info *thread) {
 114     return thread->id == ptid;
 115   });
 116 }
 117
 118 /* Find a thread associated with the given PROCESS, or NULL if no
 119    such thread exists.  */
 120
 121 static struct thread_info *
 122 find_thread_process (const struct process_info *const process)
 123 {
 124   return find_any_thread_of_pid (process->pid);
 125 }
 126
 127 /* See gdbthread.h.  */
 128
 129 struct thread_info *
 130 find_any_thread_of_pid (int pid)
 131 {
 132   return find_thread (pid, [] (thread_info *thread) {
 133     return true;
 134   });
 135 }
 136
 137 static void
 138 free_one_thread (thread_info *thread)
 139 {
 140   free_register_cache (thread_regcache_data (thread));
 141   free (thread);
 142 }
 143
 144 void
 145 remove_thread (struct thread_info *thread)
 146 {
 147   if (thread->btrace != NULL)
 148     target_disable_btrace (thread->btrace);
 149
 150   discard_queued_stop_replies (ptid_of (thread));
 151   all_threads.remove (thread);
 152   free_one_thread (thread);
 153   if (current_thread == thread)
 154     current_thread = NULL;
 155 }
 156
 157 void *
 158 thread_target_data (struct thread_info *thread)
 159 {
 160   return thread->target_data;
 161 }
 162
 163 struct regcache *
 164 thread_regcache_data (struct thread_info *thread)
 165 {
 166   return thread->regcache_data;
 167 }
 168
 169 void
 170 set_thread_regcache_data (struct thread_info *thread, struct regcache *data)
 171 {
 172   thread->regcache_data = data;
 173 }
 174
 175 void
 176 clear_inferiors (void)
 177 {
 178   for_each_inferior (&all_threads, free_one_thread);
 179   all_threads.clear ();
 180
 181   clear_dlls ();
 182
 183   current_thread = NULL;
 184 }
 185
 186 struct process_info *
 187 add_process (int pid, int attached)
 188 {
 189   process_info *process = new process_info (pid, attached);
 190
 191   all_processes.push_back (process);
 192
 193   return process;
 194 }
 195
 196 /* Remove a process from the common process list and free the memory
 197    allocated for it.
 198    The caller is responsible for freeing private data first.  */
 199
 200 void
 201 remove_process (struct process_info *process)
 202 {
 203   clear_symbol_cache (&process->symbol_cache);
 204   free_all_breakpoints (process);
 205   gdb_assert (find_thread_process (process) == NULL);
 206   all_processes.remove (process);
 207   delete process;
 208 }
 209
 210 process_info *
 211 find_process_pid (int pid)
 212 {
 213   return find_process ([&] (process_info *process) {
 214     return process->pid == pid;
 215   });
 216 }
 217
 218 /* Get the first process in the process list, or NULL if the list is empty.  */
 219
 220 process_info *
 221 get_first_process (void)
 222 {
 223   if (!all_processes.empty ())
 224     return all_processes.front ();
 225   else
 226     return NULL;
 227 }
 228
 229 /* Return non-zero if there are any inferiors that we have created
 230    (as opposed to attached-to).  */
 231
 232 int
 233 have_started_inferiors_p (void)
 234 {
 235   return find_process ([] (process_info *process) {
 236     return !process->attached;
 237   }) != NULL;
 238 }
 239
 240 /* Return non-zero if there are any inferiors that we have attached to.  */
 241
 242 int
 243 have_attached_inferiors_p (void)
 244 {
 245   return find_process ([] (process_info *process) {
 246     return process->attached;
 247   }) != NULL;
 248 }
 249
 250 struct process_info *
 251 get_thread_process (const struct thread_info *thread)
 252 {
 253   return find_process_pid (thread->id.pid ());
 254 }
 255
 256 struct process_info *
 257 current_process (void)
 258 {
 259   gdb_assert (current_thread != NULL);
 260   return get_thread_process (current_thread);
 261 }
 262
 263 static void
 264 do_restore_current_thread_cleanup (void *arg)
 265 {
 266   current_thread = (struct thread_info *) arg;
 267 }
 268
 269 struct cleanup *
 270 make_cleanup_restore_current_thread (void)
 271 {
 272   return make_cleanup (do_restore_current_thread_cleanup, current_thread);
 273 }
 274
 275 /* See common/common-gdbthread.h.  */
 276
 277 void
 278 switch_to_thread (ptid_t ptid)
 279 {
 280   gdb_assert (ptid != minus_one_ptid);
 281   current_thread = find_thread_ptid (ptid);
 282 }
 283
 284 /* See common/common-inferior.h.  */
 285
 286 const char *
 287 get_inferior_cwd ()
 288 {
 289   return current_inferior_cwd;
 290 }
 291
 292 /* See common/common-inferior.h.  */
 293
 294 void
 295 set_inferior_cwd (const char *cwd)
 296 {
 297   xfree ((void *) current_inferior_cwd);
 298   if (cwd != NULL)
 299     current_inferior_cwd = xstrdup (cwd);
 300   else
 301     current_inferior_cwd = NULL;
 302 }