gdb/gdbserver/inferiors.c

   1 /* Inferior process information for the remote server for GDB.
   2    Copyright (C) 2002, 2005, 2007, 2008, 2009 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 <stdlib.h>
  22
  23 #include "server.h"
  24
  25 struct thread_info
  26 {
  27   struct inferior_list_entry entry;
  28   void *target_data;
  29   void *regcache_data;
  30   unsigned int gdb_id;
  31 };
  32
  33 struct inferior_list all_processes;
  34 struct inferior_list all_threads;
  35 struct inferior_list all_dlls;
  36 int dlls_changed;
  37
  38 struct thread_info *current_inferior;
  39
  40
  41 /* Oft used ptids */
  42 ptid_t null_ptid;
  43 ptid_t minus_one_ptid;
  44
  45 /* Create a ptid given the necessary PID, LWP, and TID components.  */
  46
  47 ptid_t
  48 ptid_build (int pid, long lwp, long tid)
  49 {
  50   ptid_t ptid;
  51
  52   ptid.pid = pid;
  53   ptid.lwp = lwp;
  54   ptid.tid = tid;
  55   return ptid;
  56 }
  57
  58 /* Create a ptid from just a pid.  */
  59
  60 ptid_t
  61 pid_to_ptid (int pid)
  62 {
  63   return ptid_build (pid, 0, 0);
  64 }
  65
  66 /* Fetch the pid (process id) component from a ptid.  */
  67
  68 int
  69 ptid_get_pid (ptid_t ptid)
  70 {
  71   return ptid.pid;
  72 }
  73
  74 /* Fetch the lwp (lightweight process) component from a ptid.  */
  75
  76 long
  77 ptid_get_lwp (ptid_t ptid)
  78 {
  79   return ptid.lwp;
  80 }
  81
  82 /* Fetch the tid (thread id) component from a ptid.  */
  83
  84 long
  85 ptid_get_tid (ptid_t ptid)
  86 {
  87   return ptid.tid;
  88 }
  89
  90 /* ptid_equal() is used to test equality of two ptids.  */
  91
  92 int
  93 ptid_equal (ptid_t ptid1, ptid_t ptid2)
  94 {
  95   return (ptid1.pid == ptid2.pid
  96           && ptid1.lwp == ptid2.lwp
  97           && ptid1.tid == ptid2.tid);
  98 }
  99
 100 /* Return true if this ptid represents a process.  */
 101
 102 int
 103 ptid_is_pid (ptid_t ptid)
 104 {
 105   if (ptid_equal (minus_one_ptid, ptid))
 106     return 0;
 107   if (ptid_equal (null_ptid, ptid))
 108     return 0;
 109
 110   return (ptid_get_pid (ptid) != 0
 111           && ptid_get_lwp (ptid) == 0
 112           && ptid_get_tid (ptid) == 0);
 113 }
 114
 115 #define get_thread(inf) ((struct thread_info *)(inf))
 116 #define get_dll(inf) ((struct dll_info *)(inf))
 117
 118 void
 119 add_inferior_to_list (struct inferior_list *list,
 120                       struct inferior_list_entry *new_inferior)
 121 {
 122   new_inferior->next = NULL;
 123   if (list->tail != NULL)
 124     list->tail->next = new_inferior;
 125   else
 126     list->head = new_inferior;
 127   list->tail = new_inferior;
 128 }
 129
 130 void
 131 for_each_inferior (struct inferior_list *list,
 132                    void (*action) (struct inferior_list_entry *))
 133 {
 134   struct inferior_list_entry *cur = list->head, *next;
 135
 136   while (cur != NULL)
 137     {
 138       next = cur->next;
 139       (*action) (cur);
 140       cur = next;
 141     }
 142 }
 143
 144 void
 145 remove_inferior (struct inferior_list *list,
 146                  struct inferior_list_entry *entry)
 147 {
 148   struct inferior_list_entry **cur;
 149
 150   if (list->head == entry)
 151     {
 152       list->head = entry->next;
 153       if (list->tail == entry)
 154         list->tail = list->head;
 155       return;
 156     }
 157
 158   cur = &list->head;
 159   while (*cur && (*cur)->next != entry)
 160     cur = &(*cur)->next;
 161
 162   if (*cur == NULL)
 163     return;
 164
 165   (*cur)->next = entry->next;
 166
 167   if (list->tail == entry)
 168     list->tail = *cur;
 169 }
 170
 171 void
 172 add_thread (ptid_t thread_id, void *target_data)
 173 {
 174   struct thread_info *new_thread = xmalloc (sizeof (*new_thread));
 175
 176   memset (new_thread, 0, sizeof (*new_thread));
 177
 178   new_thread->entry.id = thread_id;
 179
 180   add_inferior_to_list (&all_threads, & new_thread->entry);
 181
 182   if (current_inferior == NULL)
 183     current_inferior = new_thread;
 184
 185   new_thread->target_data = target_data;
 186   set_inferior_regcache_data (new_thread, new_register_cache ());
 187 }
 188
 189 ptid_t
 190 thread_id_to_gdb_id (ptid_t thread_id)
 191 {
 192   struct inferior_list_entry *inf = all_threads.head;
 193
 194   while (inf != NULL)
 195     {
 196       if (ptid_equal (inf->id, thread_id))
 197         return thread_id;
 198       inf = inf->next;
 199     }
 200
 201   return null_ptid;
 202 }
 203
 204 ptid_t
 205 thread_to_gdb_id (struct thread_info *thread)
 206 {
 207   return thread->entry.id;
 208 }
 209
 210 struct thread_info *
 211 find_thread_pid (ptid_t ptid)
 212 {
 213   struct inferior_list_entry *inf = all_threads.head;
 214
 215   while (inf != NULL)
 216     {
 217       struct thread_info *thread = get_thread (inf);
 218       if (ptid_equal (thread->entry.id, ptid))
 219         return thread;
 220       inf = inf->next;
 221     }
 222
 223   return NULL;
 224 }
 225
 226 ptid_t
 227 gdb_id_to_thread_id (ptid_t gdb_id)
 228 {
 229   struct thread_info *thread = find_thread_pid (gdb_id);
 230
 231   return thread ? thread->entry.id : null_ptid;
 232 }
 233
 234 static void
 235 free_one_thread (struct inferior_list_entry *inf)
 236 {
 237   struct thread_info *thread = get_thread (inf);
 238   free_register_cache (inferior_regcache_data (thread));
 239   free (thread);
 240 }
 241
 242 void
 243 remove_thread (struct thread_info *thread)
 244 {
 245   remove_inferior (&all_threads, (struct inferior_list_entry *) thread);
 246   free_one_thread (&thread->entry);
 247 }
 248
 249 struct inferior_list_entry *
 250 find_inferior (struct inferior_list *list,
 251                int (*func) (struct inferior_list_entry *, void *), void *arg)
 252 {
 253   struct inferior_list_entry *inf = list->head;
 254
 255   while (inf != NULL)
 256     {
 257       struct inferior_list_entry *next;
 258
 259       next = inf->next;
 260       if ((*func) (inf, arg))
 261         return inf;
 262       inf = next;
 263     }
 264
 265   return NULL;
 266 }
 267
 268 struct inferior_list_entry *
 269 find_inferior_id (struct inferior_list *list, ptid_t id)
 270 {
 271   struct inferior_list_entry *inf = list->head;
 272
 273   while (inf != NULL)
 274     {
 275       if (ptid_equal (inf->id, id))
 276         return inf;
 277       inf = inf->next;
 278     }
 279
 280   return NULL;
 281 }
 282
 283 void *
 284 inferior_target_data (struct thread_info *inferior)
 285 {
 286   return inferior->target_data;
 287 }
 288
 289 void
 290 set_inferior_target_data (struct thread_info *inferior, void *data)
 291 {
 292   inferior->target_data = data;
 293 }
 294
 295 void *
 296 inferior_regcache_data (struct thread_info *inferior)
 297 {
 298   return inferior->regcache_data;
 299 }
 300
 301 void
 302 set_inferior_regcache_data (struct thread_info *inferior, void *data)
 303 {
 304   inferior->regcache_data = data;
 305 }
 306
 307 static void
 308 free_one_dll (struct inferior_list_entry *inf)
 309 {
 310   struct dll_info *dll = get_dll (inf);
 311   if (dll->name != NULL)
 312     free (dll->name);
 313   free (dll);
 314 }
 315
 316 /* Find a DLL with the same name and/or base address.  A NULL name in
 317    the key is ignored; so is an all-ones base address.  */
 318
 319 static int
 320 match_dll (struct inferior_list_entry *inf, void *arg)
 321 {
 322   struct dll_info *iter = (void *) inf;
 323   struct dll_info *key = arg;
 324
 325   if (key->base_addr != ~(CORE_ADDR) 0
 326       && iter->base_addr == key->base_addr)
 327     return 1;
 328   else if (key->name != NULL
 329            && iter->name != NULL
 330            && strcmp (key->name, iter->name) == 0)
 331     return 1;
 332
 333   return 0;
 334 }
 335
 336 /* Record a newly loaded DLL at BASE_ADDR.  */
 337
 338 void
 339 loaded_dll (const char *name, CORE_ADDR base_addr)
 340 {
 341   struct dll_info *new_dll = xmalloc (sizeof (*new_dll));
 342   memset (new_dll, 0, sizeof (*new_dll));
 343
 344   new_dll->entry.id = minus_one_ptid;
 345
 346   new_dll->name = xstrdup (name);
 347   new_dll->base_addr = base_addr;
 348
 349   add_inferior_to_list (&all_dlls, &new_dll->entry);
 350   dlls_changed = 1;
 351 }
 352
 353 /* Record that the DLL with NAME and BASE_ADDR has been unloaded.  */
 354
 355 void
 356 unloaded_dll (const char *name, CORE_ADDR base_addr)
 357 {
 358   struct dll_info *dll;
 359   struct dll_info key_dll;
 360
 361   /* Be careful not to put the key DLL in any list.  */
 362   key_dll.name = (char *) name;
 363   key_dll.base_addr = base_addr;
 364
 365   dll = (void *) find_inferior (&all_dlls, match_dll, &key_dll);
 366   remove_inferior (&all_dlls, &dll->entry);
 367   free_one_dll (&dll->entry);
 368   dlls_changed = 1;
 369 }
 370
 371 #define clear_list(LIST) \
 372   do { (LIST)->head = (LIST)->tail = NULL; } while (0)
 373
 374 void
 375 clear_inferiors (void)
 376 {
 377   for_each_inferior (&all_threads, free_one_thread);
 378   for_each_inferior (&all_dlls, free_one_dll);
 379
 380   clear_list (&all_threads);
 381   clear_list (&all_dlls);
 382
 383   current_inferior = NULL;
 384 }
 385
 386 /* Two utility functions for a truly degenerate inferior_list: a simple
 387    PID listing.  */
 388
 389 void
 390 add_pid_to_list (struct inferior_list *list, unsigned long pid)
 391 {
 392   struct inferior_list_entry *new_entry;
 393
 394   new_entry = xmalloc (sizeof (struct inferior_list_entry));
 395   new_entry->id = pid_to_ptid (pid);
 396   add_inferior_to_list (list, new_entry);
 397 }
 398
 399 int
 400 pull_pid_from_list (struct inferior_list *list, unsigned long pid)
 401 {
 402   struct inferior_list_entry *new_entry;
 403
 404   new_entry = find_inferior_id (list, pid_to_ptid (pid));
 405   if (new_entry == NULL)
 406     return 0;
 407   else
 408     {
 409       remove_inferior (list, new_entry);
 410       free (new_entry);
 411       return 1;
 412     }
 413 }
 414
 415 struct process_info *
 416 add_process (int pid, int attached)
 417 {
 418   struct process_info *process;
 419
 420   process = xcalloc (1, sizeof (*process));
 421
 422   process->head.id = pid_to_ptid (pid);
 423   process->attached = attached;
 424
 425   add_inferior_to_list (&all_processes, &process->head);
 426
 427   return process;
 428 }
 429
 430 void
 431 remove_process (struct process_info *process)
 432 {
 433   clear_symbol_cache (&process->symbol_cache);
 434   free_all_breakpoints (process);
 435   remove_inferior (&all_processes, &process->head);
 436 }
 437
 438 struct process_info *
 439 find_process_pid (int pid)
 440 {
 441   return (struct process_info *)
 442     find_inferior_id (&all_processes, pid_to_ptid (pid));
 443 }
 444
 445 struct process_info *
 446 get_thread_process (struct thread_info *thread)
 447 {
 448   int pid = ptid_get_pid (thread->entry.id);
 449   return find_process_pid (pid);
 450 }
 451
 452 struct process_info *
 453 current_process (void)
 454 {
 455   if (current_inferior == NULL)
 456     fatal ("Current inferior requested, but current_inferior is NULL\n");
 457
 458   return get_thread_process (current_inferior);
 459 }
 460
 461 void
 462 initialize_inferiors (void)
 463 {
 464   null_ptid = ptid_build (0, 0, 0);
 465   minus_one_ptid = ptid_build (-1, 0, 0);
 466 }