gdb/bsd-uthread.c

   1 /* BSD user-level threads support.
   2
   3    Copyright (C) 2005, 2007, 2008 Free Software Foundation, Inc.
   4
   5    This file is part of GDB.
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 3 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  19
  20 #include "defs.h"
  21 #include "gdbcore.h"
  22 #include "gdbthread.h"
  23 #include "inferior.h"
  24 #include "objfiles.h"
  25 #include "observer.h"
  26 #include "regcache.h"
  27 #include "solib.h"
  28 #include "solist.h"
  29 #include "symfile.h"
  30 #include "target.h"
  31
  32 #include "gdb_assert.h"
  33 #include "gdb_obstack.h"
  34
  35 #include "bsd-uthread.h"
  36
  37 /* HACK: Save the bsd_uthreads ops returned by bsd_uthread_target.  */
  38 static struct target_ops *bsd_uthread_ops_hack;
  39 \f
  40
  41 /* Architecture-specific operations.  */
  42
  43 /* Per-architecture data key.  */
  44 static struct gdbarch_data *bsd_uthread_data;
  45
  46 struct bsd_uthread_ops
  47 {
  48   /* Supply registers for an inactive thread to a register cache.  */
  49   void (*supply_uthread)(struct regcache *, int, CORE_ADDR);
  50
  51   /* Collect registers for an inactive thread from a register cache.  */
  52   void (*collect_uthread)(const struct regcache *, int, CORE_ADDR);
  53 };
  54
  55 static void *
  56 bsd_uthread_init (struct obstack *obstack)
  57 {
  58   struct bsd_uthread_ops *ops;
  59
  60   ops = OBSTACK_ZALLOC (obstack, struct bsd_uthread_ops);
  61   return ops;
  62 }
  63
  64 /* Set the function that supplies registers from an inactive thread
  65    for architecture GDBARCH to SUPPLY_UTHREAD.  */
  66
  67 void
  68 bsd_uthread_set_supply_uthread (struct gdbarch *gdbarch,
  69                                 void (*supply_uthread) (struct regcache *,
  70                                                         int, CORE_ADDR))
  71 {
  72   struct bsd_uthread_ops *ops = gdbarch_data (gdbarch, bsd_uthread_data);
  73   ops->supply_uthread = supply_uthread;
  74 }
  75
  76 /* Set the function that collects registers for an inactive thread for
  77    architecture GDBARCH to SUPPLY_UTHREAD.  */
  78
  79 void
  80 bsd_uthread_set_collect_uthread (struct gdbarch *gdbarch,
  81                          void (*collect_uthread) (const struct regcache *,
  82                                                   int, CORE_ADDR))
  83 {
  84   struct bsd_uthread_ops *ops = gdbarch_data (gdbarch, bsd_uthread_data);
  85   ops->collect_uthread = collect_uthread;
  86 }
  87
  88 /* Magic number to help recognize a valid thread structure.  */
  89 #define BSD_UTHREAD_PTHREAD_MAGIC       0xd09ba115
  90
  91 /* Check whether the thread structure at ADDR is valid.  */
  92
  93 static void
  94 bsd_uthread_check_magic (CORE_ADDR addr)
  95 {
  96   ULONGEST magic = read_memory_unsigned_integer (addr, 4);
  97
  98   if (magic != BSD_UTHREAD_PTHREAD_MAGIC)
  99     error (_("Bad magic"));
 100 }
 101
 102 /* Thread states.  */
 103 #define BSD_UTHREAD_PS_RUNNING  0
 104 #define BSD_UTHREAD_PS_DEAD     18
 105
 106 /* Address of the pointer to the the thread structure for the running
 107    thread.  */
 108 static CORE_ADDR bsd_uthread_thread_run_addr;
 109
 110 /* Address of the list of all threads.  */
 111 static CORE_ADDR bsd_uthread_thread_list_addr;
 112
 113 /* Offsets of various "interesting" bits in the thread structure.  */
 114 static int bsd_uthread_thread_state_offset = -1;
 115 static int bsd_uthread_thread_next_offset = -1;
 116 static int bsd_uthread_thread_ctx_offset;
 117
 118 /* Name of shared threads library.  */
 119 static const char *bsd_uthread_solib_name;
 120
 121 /* Non-zero if the thread startum implemented by this module is active.  */
 122 static int bsd_uthread_active;
 123
 124 static CORE_ADDR
 125 bsd_uthread_lookup_address (const char *name, struct objfile *objfile)
 126 {
 127   struct minimal_symbol *sym;
 128
 129   sym = lookup_minimal_symbol (name, NULL, objfile);
 130   if (sym)
 131     return SYMBOL_VALUE_ADDRESS (sym);
 132
 133   return 0;
 134 }
 135
 136 static int
 137 bsd_uthread_lookup_offset (const char *name, struct objfile *objfile)
 138 {
 139   CORE_ADDR addr;
 140
 141   addr = bsd_uthread_lookup_address (name, objfile);
 142   if (addr == 0)
 143     return 0;
 144
 145   return read_memory_unsigned_integer (addr, 4);
 146 }
 147
 148 /* If OBJFILE contains the symbols corresponding to one of the
 149    supported user-level threads libraries, activate the thread stratum
 150    implemented by this module.  */
 151
 152 static int
 153 bsd_uthread_activate (struct objfile *objfile)
 154 {
 155   struct gdbarch *gdbarch = current_gdbarch;
 156   struct bsd_uthread_ops *ops = gdbarch_data (gdbarch, bsd_uthread_data);
 157
 158   /* Skip if the thread stratum has already been activated.  */
 159   if (bsd_uthread_active)
 160     return 0;
 161
 162   /* There's no point in enabling this module if no
 163      architecture-specific operations are provided.  */
 164   if (!ops->supply_uthread)
 165     return 0;
 166
 167   bsd_uthread_thread_run_addr =
 168     bsd_uthread_lookup_address ("_thread_run", objfile);
 169   if (bsd_uthread_thread_run_addr == 0)
 170     return 0;
 171
 172   bsd_uthread_thread_list_addr =
 173     bsd_uthread_lookup_address ("_thread_list", objfile);
 174   if (bsd_uthread_thread_list_addr == 0)
 175     return 0;
 176
 177   bsd_uthread_thread_state_offset =
 178     bsd_uthread_lookup_offset ("_thread_state_offset", objfile);
 179   if (bsd_uthread_thread_state_offset == 0)
 180     return 0;
 181
 182   bsd_uthread_thread_next_offset =
 183     bsd_uthread_lookup_offset ("_thread_next_offset", objfile);
 184   if (bsd_uthread_thread_next_offset == 0)
 185     return 0;
 186
 187   bsd_uthread_thread_ctx_offset =
 188     bsd_uthread_lookup_offset ("_thread_ctx_offset", objfile);
 189
 190   push_target (bsd_uthread_ops_hack);
 191   bsd_uthread_active = 1;
 192   return 1;
 193 }
 194
 195 /* Cleanup due to deactivation.  */
 196
 197 static void
 198 bsd_uthread_close (int quitting)
 199 {
 200   bsd_uthread_active = 0;
 201   bsd_uthread_thread_run_addr = 0;
 202   bsd_uthread_thread_list_addr = 0;
 203   bsd_uthread_thread_state_offset = 0;
 204   bsd_uthread_thread_next_offset = 0;
 205   bsd_uthread_thread_ctx_offset = 0;
 206   bsd_uthread_solib_name = NULL;
 207 }
 208
 209 /* Deactivate the thread stratum implemented by this module.  */
 210
 211 static void
 212 bsd_uthread_deactivate (void)
 213 {
 214   /* Skip if the thread stratum has already been deactivated.  */
 215   if (!bsd_uthread_active)
 216     return;
 217
 218   unpush_target (bsd_uthread_ops_hack);
 219 }
 220
 221 void
 222 bsd_uthread_inferior_created (struct target_ops *ops, int from_tty)
 223 {
 224   bsd_uthread_activate (NULL);
 225 }
 226
 227 /* Likely candidates for the threads library.  */
 228 static const char *bsd_uthread_solib_names[] =
 229 {
 230   "/usr/lib/libc_r.so",         /* FreeBSD */
 231   "/usr/lib/libpthread.so",     /* OpenBSD */
 232   NULL
 233 };
 234
 235 void
 236 bsd_uthread_solib_loaded (struct so_list *so)
 237 {
 238   const char **names = bsd_uthread_solib_names;
 239
 240   for (names = bsd_uthread_solib_names; *names; names++)
 241     {
 242       if (strncmp (so->so_original_name, *names, strlen (*names)) == 0)
 243         {
 244           solib_read_symbols (so, so->from_tty);
 245
 246           if (bsd_uthread_activate (so->objfile))
 247             {
 248               bsd_uthread_solib_name = so->so_original_name;
 249               return;
 250             }
 251         }
 252     }
 253 }
 254
 255 void
 256 bsd_uthread_solib_unloaded (struct so_list *so)
 257 {
 258   if (!bsd_uthread_solib_name)
 259     return;
 260
 261   if (strcmp (so->so_original_name, bsd_uthread_solib_name) == 0)
 262     bsd_uthread_deactivate ();
 263 }
 264
 265 static void
 266 bsd_uthread_mourn_inferior (void)
 267 {
 268   find_target_beneath (bsd_uthread_ops_hack)->to_mourn_inferior ();
 269   bsd_uthread_deactivate ();
 270 }
 271
 272 static void
 273 bsd_uthread_fetch_registers (struct regcache *regcache, int regnum)
 274 {
 275   struct gdbarch *gdbarch = get_regcache_arch (regcache);
 276   struct bsd_uthread_ops *ops = gdbarch_data (gdbarch, bsd_uthread_data);
 277   CORE_ADDR addr = ptid_get_tid (inferior_ptid);
 278   CORE_ADDR active_addr;
 279
 280   /* Always fetch the appropriate registers from the layer beneath.  */
 281   find_target_beneath (bsd_uthread_ops_hack)->to_fetch_registers (regcache, regnum);
 282
 283   /* FIXME: That might have gotten us more than we asked for.  Make
 284      sure we overwrite all relevant registers with values from the
 285      thread structure.  This can go once we fix the underlying target.  */
 286   regnum = -1;
 287
 288   active_addr = read_memory_typed_address (bsd_uthread_thread_run_addr,
 289                                            builtin_type_void_data_ptr);
 290   if (addr != 0 && addr != active_addr)
 291     {
 292       bsd_uthread_check_magic (addr);
 293       ops->supply_uthread (regcache, regnum,
 294                            addr + bsd_uthread_thread_ctx_offset);
 295     }
 296 }
 297
 298 static void
 299 bsd_uthread_store_registers (struct regcache *regcache, int regnum)
 300 {
 301   struct gdbarch *gdbarch = get_regcache_arch (regcache);
 302   struct bsd_uthread_ops *ops = gdbarch_data (gdbarch, bsd_uthread_data);
 303   CORE_ADDR addr = ptid_get_tid (inferior_ptid);
 304   CORE_ADDR active_addr;
 305
 306   active_addr = read_memory_typed_address (bsd_uthread_thread_run_addr,
 307                                            builtin_type_void_data_ptr);
 308   if (addr != 0 && addr != active_addr)
 309     {
 310       bsd_uthread_check_magic (addr);
 311       ops->collect_uthread (regcache, regnum,
 312                             addr + bsd_uthread_thread_ctx_offset);
 313     }
 314   else
 315     {
 316       /* Updating the thread that is currently running; pass the
 317          request to the layer beneath.  */
 318       find_target_beneath (bsd_uthread_ops_hack)->to_store_registers (regcache, regnum);
 319     }
 320 }
 321
 322 /* FIXME: This function is only there because otherwise GDB tries to
 323    invoke deprecate_xfer_memory.  */
 324
 325 static LONGEST
 326 bsd_uthread_xfer_partial (struct target_ops *ops, enum target_object object,
 327                           const char *annex, gdb_byte *readbuf,
 328                           const gdb_byte *writebuf,
 329                           ULONGEST offset, LONGEST len)
 330 {
 331   gdb_assert (ops->beneath->to_xfer_partial);
 332   return ops->beneath->to_xfer_partial (ops->beneath, object, annex, readbuf,
 333                                         writebuf, offset, len);
 334 }
 335
 336 static ptid_t
 337 bsd_uthread_wait (ptid_t ptid, struct target_waitstatus *status)
 338 {
 339   CORE_ADDR addr;
 340
 341   /* Pass the request to the layer beneath.  */
 342   ptid = find_target_beneath (bsd_uthread_ops_hack)->to_wait (ptid, status);
 343
 344   /* If the process is no longer alive, there's no point in figuring
 345      out the thread ID.  It will fail anyway.  */
 346   if (status->kind == TARGET_WAITKIND_SIGNALLED
 347       || status->kind == TARGET_WAITKIND_EXITED)
 348     return ptid;
 349
 350   /* Fetch the corresponding thread ID, and augment the returned
 351      process ID with it.  */
 352   addr = read_memory_typed_address (bsd_uthread_thread_run_addr,
 353                                     builtin_type_void_data_ptr);
 354   if (addr != 0)
 355     {
 356       gdb_byte buf[4];
 357
 358       /* FIXME: For executables linked statically with the threads
 359          library, we end up here before the program has actually been
 360          executed.  In that case ADDR will be garbage since it has
 361          been read from the wrong virtual memory image.  */
 362       if (target_read_memory (addr, buf, 4) == 0)
 363         {
 364           ULONGEST magic = extract_unsigned_integer (buf, 4);
 365           if (magic == BSD_UTHREAD_PTHREAD_MAGIC)
 366             ptid = ptid_build (ptid_get_pid (ptid), 0, addr);
 367         }
 368     }
 369
 370   /* If INFERIOR_PTID doesn't have a tid member yet, and we now have a
 371      ptid with tid set, then ptid is still the initial thread of
 372      the process.  Notify GDB core about it.  */
 373   if (ptid_get_tid (inferior_ptid) == 0
 374       && ptid_get_tid (ptid) != 0 && !in_thread_list (ptid))
 375     thread_change_ptid (inferior_ptid, ptid);
 376
 377   /* Don't let the core see a ptid without a corresponding thread.  */
 378   if (!in_thread_list (ptid) || is_exited (ptid))
 379     add_thread (ptid);
 380
 381   return ptid;
 382 }
 383
 384 static void
 385 bsd_uthread_resume (ptid_t ptid, int step, enum target_signal sig)
 386 {
 387   /* Pass the request to the layer beneath.  */
 388   find_target_beneath (bsd_uthread_ops_hack)->to_resume (ptid, step, sig);
 389 }
 390
 391 static int
 392 bsd_uthread_thread_alive (ptid_t ptid)
 393 {
 394   CORE_ADDR addr = ptid_get_tid (inferior_ptid);
 395
 396   if (addr != 0)
 397     {
 398       int offset = bsd_uthread_thread_state_offset;
 399       ULONGEST state;
 400
 401       bsd_uthread_check_magic (addr);
 402
 403       state = read_memory_unsigned_integer (addr + offset, 4);
 404       if (state == BSD_UTHREAD_PS_DEAD)
 405         return 0;
 406     }
 407
 408   return find_target_beneath (bsd_uthread_ops_hack)->to_thread_alive (ptid);
 409 }
 410
 411 static void
 412 bsd_uthread_find_new_threads (void)
 413 {
 414   pid_t pid = ptid_get_pid (inferior_ptid);
 415   int offset = bsd_uthread_thread_next_offset;
 416   CORE_ADDR addr;
 417
 418   addr = read_memory_typed_address (bsd_uthread_thread_list_addr,
 419                                     builtin_type_void_data_ptr);
 420   while (addr != 0)
 421     {
 422       ptid_t ptid = ptid_build (pid, 0, addr);
 423
 424       if (!in_thread_list (ptid) || is_exited (ptid))
 425         add_thread (ptid);
 426
 427       addr = read_memory_typed_address (addr + offset,
 428                                         builtin_type_void_data_ptr);
 429     }
 430 }
 431
 432 /* Possible states a thread can be in.  */
 433 static char *bsd_uthread_state[] =
 434 {
 435   "RUNNING",
 436   "SIGTHREAD",
 437   "MUTEX_WAIT",
 438   "COND_WAIT",
 439   "FDLR_WAIT",
 440   "FDLW_WAIT",
 441   "FDR_WAIT",
 442   "FDW_WAIT",
 443   "FILE_WAIT",
 444   "POLL_WAIT",
 445   "SELECT_WAIT",
 446   "SLEEP_WAIT",
 447   "WAIT_WAIT",
 448   "SIGSUSPEND",
 449   "SIGWAIT",
 450   "SPINBLOCK",
 451   "JOIN",
 452   "SUSPENDED",
 453   "DEAD",
 454   "DEADLOCK"
 455 };
 456
 457 /* Return a string describing th state of the thread specified by
 458    INFO.  */
 459
 460 static char *
 461 bsd_uthread_extra_thread_info (struct thread_info *info)
 462 {
 463   CORE_ADDR addr = ptid_get_tid (info->ptid);
 464
 465   if (addr != 0)
 466     {
 467       int offset = bsd_uthread_thread_state_offset;
 468       ULONGEST state;
 469
 470       state = read_memory_unsigned_integer (addr + offset, 4);
 471       if (state < ARRAY_SIZE (bsd_uthread_state))
 472         return bsd_uthread_state[state];
 473     }
 474
 475   return NULL;
 476 }
 477
 478 static char *
 479 bsd_uthread_pid_to_str (ptid_t ptid)
 480 {
 481   if (ptid_get_tid (ptid) != 0)
 482     {
 483       static char buf[64];
 484
 485       xsnprintf (buf, sizeof buf, "process %d, thread 0x%lx",
 486                  ptid_get_pid (ptid), ptid_get_tid (ptid));
 487       return buf;
 488     }
 489
 490   return normal_pid_to_str (ptid);
 491 }
 492
 493 struct target_ops *
 494 bsd_uthread_target (void)
 495 {
 496   struct target_ops *t = XZALLOC (struct target_ops);
 497
 498   t->to_shortname = "bsd-uthreads";
 499   t->to_longname = "BSD user-level threads";
 500   t->to_doc = "BSD user-level threads";
 501   t->to_close = bsd_uthread_close;
 502   t->to_mourn_inferior = bsd_uthread_mourn_inferior;
 503   t->to_fetch_registers = bsd_uthread_fetch_registers;
 504   t->to_store_registers = bsd_uthread_store_registers;
 505   t->to_xfer_partial = bsd_uthread_xfer_partial;
 506   t->to_wait = bsd_uthread_wait;
 507   t->to_resume = bsd_uthread_resume;
 508   t->to_thread_alive = bsd_uthread_thread_alive;
 509   t->to_find_new_threads = bsd_uthread_find_new_threads;
 510   t->to_extra_thread_info = bsd_uthread_extra_thread_info;
 511   t->to_pid_to_str = bsd_uthread_pid_to_str;
 512   t->to_stratum = thread_stratum;
 513   t->to_magic = OPS_MAGIC;
 514   bsd_uthread_ops_hack = t;
 515
 516   return t;
 517 }
 518
 519 void
 520 _initialize_bsd_uthread (void)
 521 {
 522   add_target (bsd_uthread_target ());
 523
 524   bsd_uthread_data = gdbarch_data_register_pre_init (bsd_uthread_init);
 525
 526   observer_attach_inferior_created (bsd_uthread_inferior_created);
 527   observer_attach_solib_loaded (bsd_uthread_solib_loaded);
 528   observer_attach_solib_unloaded (bsd_uthread_solib_unloaded);
 529 }