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 static CORE_ADDR
 149 bsd_uthread_read_memory_address (CORE_ADDR addr)
 150 {
 151   struct type *ptr_type = builtin_type (target_gdbarch)->builtin_data_ptr;
 152   return read_memory_typed_address (addr, ptr_type);
 153 }
 154
 155 /* If OBJFILE contains the symbols corresponding to one of the
 156    supported user-level threads libraries, activate the thread stratum
 157    implemented by this module.  */
 158
 159 static int
 160 bsd_uthread_activate (struct objfile *objfile)
 161 {
 162   struct gdbarch *gdbarch = current_gdbarch;
 163   struct bsd_uthread_ops *ops = gdbarch_data (gdbarch, bsd_uthread_data);
 164
 165   /* Skip if the thread stratum has already been activated.  */
 166   if (bsd_uthread_active)
 167     return 0;
 168
 169   /* There's no point in enabling this module if no
 170      architecture-specific operations are provided.  */
 171   if (!ops->supply_uthread)
 172     return 0;
 173
 174   bsd_uthread_thread_run_addr =
 175     bsd_uthread_lookup_address ("_thread_run", objfile);
 176   if (bsd_uthread_thread_run_addr == 0)
 177     return 0;
 178
 179   bsd_uthread_thread_list_addr =
 180     bsd_uthread_lookup_address ("_thread_list", objfile);
 181   if (bsd_uthread_thread_list_addr == 0)
 182     return 0;
 183
 184   bsd_uthread_thread_state_offset =
 185     bsd_uthread_lookup_offset ("_thread_state_offset", objfile);
 186   if (bsd_uthread_thread_state_offset == 0)
 187     return 0;
 188
 189   bsd_uthread_thread_next_offset =
 190     bsd_uthread_lookup_offset ("_thread_next_offset", objfile);
 191   if (bsd_uthread_thread_next_offset == 0)
 192     return 0;
 193
 194   bsd_uthread_thread_ctx_offset =
 195     bsd_uthread_lookup_offset ("_thread_ctx_offset", objfile);
 196
 197   push_target (bsd_uthread_ops_hack);
 198   bsd_uthread_active = 1;
 199   return 1;
 200 }
 201
 202 /* Cleanup due to deactivation.  */
 203
 204 static void
 205 bsd_uthread_close (int quitting)
 206 {
 207   bsd_uthread_active = 0;
 208   bsd_uthread_thread_run_addr = 0;
 209   bsd_uthread_thread_list_addr = 0;
 210   bsd_uthread_thread_state_offset = 0;
 211   bsd_uthread_thread_next_offset = 0;
 212   bsd_uthread_thread_ctx_offset = 0;
 213   bsd_uthread_solib_name = NULL;
 214 }
 215
 216 /* Deactivate the thread stratum implemented by this module.  */
 217
 218 static void
 219 bsd_uthread_deactivate (void)
 220 {
 221   /* Skip if the thread stratum has already been deactivated.  */
 222   if (!bsd_uthread_active)
 223     return;
 224
 225   unpush_target (bsd_uthread_ops_hack);
 226 }
 227
 228 void
 229 bsd_uthread_inferior_created (struct target_ops *ops, int from_tty)
 230 {
 231   bsd_uthread_activate (NULL);
 232 }
 233
 234 /* Likely candidates for the threads library.  */
 235 static const char *bsd_uthread_solib_names[] =
 236 {
 237   "/usr/lib/libc_r.so",         /* FreeBSD */
 238   "/usr/lib/libpthread.so",     /* OpenBSD */
 239   NULL
 240 };
 241
 242 void
 243 bsd_uthread_solib_loaded (struct so_list *so)
 244 {
 245   const char **names = bsd_uthread_solib_names;
 246
 247   for (names = bsd_uthread_solib_names; *names; names++)
 248     {
 249       if (strncmp (so->so_original_name, *names, strlen (*names)) == 0)
 250         {
 251           solib_read_symbols (so, so->from_tty);
 252
 253           if (bsd_uthread_activate (so->objfile))
 254             {
 255               bsd_uthread_solib_name = so->so_original_name;
 256               return;
 257             }
 258         }
 259     }
 260 }
 261
 262 void
 263 bsd_uthread_solib_unloaded (struct so_list *so)
 264 {
 265   if (!bsd_uthread_solib_name)
 266     return;
 267
 268   if (strcmp (so->so_original_name, bsd_uthread_solib_name) == 0)
 269     bsd_uthread_deactivate ();
 270 }
 271
 272 static void
 273 bsd_uthread_mourn_inferior (void)
 274 {
 275   find_target_beneath (bsd_uthread_ops_hack)->to_mourn_inferior ();
 276   bsd_uthread_deactivate ();
 277 }
 278
 279 static void
 280 bsd_uthread_fetch_registers (struct regcache *regcache, int regnum)
 281 {
 282   struct gdbarch *gdbarch = get_regcache_arch (regcache);
 283   struct bsd_uthread_ops *ops = gdbarch_data (gdbarch, bsd_uthread_data);
 284   CORE_ADDR addr = ptid_get_tid (inferior_ptid);
 285   CORE_ADDR active_addr;
 286
 287   /* Always fetch the appropriate registers from the layer beneath.  */
 288   find_target_beneath (bsd_uthread_ops_hack)->to_fetch_registers (regcache, regnum);
 289
 290   /* FIXME: That might have gotten us more than we asked for.  Make
 291      sure we overwrite all relevant registers with values from the
 292      thread structure.  This can go once we fix the underlying target.  */
 293   regnum = -1;
 294
 295   active_addr = bsd_uthread_read_memory_address (bsd_uthread_thread_run_addr);
 296   if (addr != 0 && addr != active_addr)
 297     {
 298       bsd_uthread_check_magic (addr);
 299       ops->supply_uthread (regcache, regnum,
 300                            addr + bsd_uthread_thread_ctx_offset);
 301     }
 302 }
 303
 304 static void
 305 bsd_uthread_store_registers (struct regcache *regcache, int regnum)
 306 {
 307   struct gdbarch *gdbarch = get_regcache_arch (regcache);
 308   struct bsd_uthread_ops *ops = gdbarch_data (gdbarch, bsd_uthread_data);
 309   CORE_ADDR addr = ptid_get_tid (inferior_ptid);
 310   CORE_ADDR active_addr;
 311
 312   active_addr = bsd_uthread_read_memory_address (bsd_uthread_thread_run_addr);
 313   if (addr != 0 && addr != active_addr)
 314     {
 315       bsd_uthread_check_magic (addr);
 316       ops->collect_uthread (regcache, regnum,
 317                             addr + bsd_uthread_thread_ctx_offset);
 318     }
 319   else
 320     {
 321       /* Updating the thread that is currently running; pass the
 322          request to the layer beneath.  */
 323       find_target_beneath (bsd_uthread_ops_hack)->to_store_registers (regcache, regnum);
 324     }
 325 }
 326
 327 /* FIXME: This function is only there because otherwise GDB tries to
 328    invoke deprecate_xfer_memory.  */
 329
 330 static LONGEST
 331 bsd_uthread_xfer_partial (struct target_ops *ops, enum target_object object,
 332                           const char *annex, gdb_byte *readbuf,
 333                           const gdb_byte *writebuf,
 334                           ULONGEST offset, LONGEST len)
 335 {
 336   gdb_assert (ops->beneath->to_xfer_partial);
 337   return ops->beneath->to_xfer_partial (ops->beneath, object, annex, readbuf,
 338                                         writebuf, offset, len);
 339 }
 340
 341 static ptid_t
 342 bsd_uthread_wait (ptid_t ptid, struct target_waitstatus *status)
 343 {
 344   CORE_ADDR addr;
 345
 346   /* Pass the request to the layer beneath.  */
 347   ptid = find_target_beneath (bsd_uthread_ops_hack)->to_wait (ptid, status);
 348
 349   /* If the process is no longer alive, there's no point in figuring
 350      out the thread ID.  It will fail anyway.  */
 351   if (status->kind == TARGET_WAITKIND_SIGNALLED
 352       || status->kind == TARGET_WAITKIND_EXITED)
 353     return ptid;
 354
 355   /* Fetch the corresponding thread ID, and augment the returned
 356      process ID with it.  */
 357   addr = bsd_uthread_read_memory_address (bsd_uthread_thread_run_addr);
 358   if (addr != 0)
 359     {
 360       gdb_byte buf[4];
 361
 362       /* FIXME: For executables linked statically with the threads
 363          library, we end up here before the program has actually been
 364          executed.  In that case ADDR will be garbage since it has
 365          been read from the wrong virtual memory image.  */
 366       if (target_read_memory (addr, buf, 4) == 0)
 367         {
 368           ULONGEST magic = extract_unsigned_integer (buf, 4);
 369           if (magic == BSD_UTHREAD_PTHREAD_MAGIC)
 370             ptid = ptid_build (ptid_get_pid (ptid), 0, addr);
 371         }
 372     }
 373
 374   /* If INFERIOR_PTID doesn't have a tid member yet, and we now have a
 375      ptid with tid set, then ptid is still the initial thread of
 376      the process.  Notify GDB core about it.  */
 377   if (ptid_get_tid (inferior_ptid) == 0
 378       && ptid_get_tid (ptid) != 0 && !in_thread_list (ptid))
 379     thread_change_ptid (inferior_ptid, ptid);
 380
 381   /* Don't let the core see a ptid without a corresponding thread.  */
 382   if (!in_thread_list (ptid) || is_exited (ptid))
 383     add_thread (ptid);
 384
 385   return ptid;
 386 }
 387
 388 static void
 389 bsd_uthread_resume (ptid_t ptid, int step, enum target_signal sig)
 390 {
 391   /* Pass the request to the layer beneath.  */
 392   find_target_beneath (bsd_uthread_ops_hack)->to_resume (ptid, step, sig);
 393 }
 394
 395 static int
 396 bsd_uthread_thread_alive (ptid_t ptid)
 397 {
 398   CORE_ADDR addr = ptid_get_tid (inferior_ptid);
 399
 400   if (addr != 0)
 401     {
 402       int offset = bsd_uthread_thread_state_offset;
 403       ULONGEST state;
 404
 405       bsd_uthread_check_magic (addr);
 406
 407       state = read_memory_unsigned_integer (addr + offset, 4);
 408       if (state == BSD_UTHREAD_PS_DEAD)
 409         return 0;
 410     }
 411
 412   return find_target_beneath (bsd_uthread_ops_hack)->to_thread_alive (ptid);
 413 }
 414
 415 static void
 416 bsd_uthread_find_new_threads (void)
 417 {
 418   pid_t pid = ptid_get_pid (inferior_ptid);
 419   int offset = bsd_uthread_thread_next_offset;
 420   CORE_ADDR addr;
 421
 422   addr = bsd_uthread_read_memory_address (bsd_uthread_thread_list_addr);
 423   while (addr != 0)
 424     {
 425       ptid_t ptid = ptid_build (pid, 0, addr);
 426
 427       if (!in_thread_list (ptid) || is_exited (ptid))
 428         {
 429           /* If INFERIOR_PTID doesn't have a tid member yet, then ptid
 430              is still the initial thread of the process.  Notify GDB
 431              core about it.  */
 432           if (ptid_get_tid (inferior_ptid) == 0)
 433             thread_change_ptid (inferior_ptid, ptid);
 434           else
 435             add_thread (ptid);
 436         }
 437
 438       addr = bsd_uthread_read_memory_address (addr + offset);
 439     }
 440 }
 441
 442 /* Possible states a thread can be in.  */
 443 static char *bsd_uthread_state[] =
 444 {
 445   "RUNNING",
 446   "SIGTHREAD",
 447   "MUTEX_WAIT",
 448   "COND_WAIT",
 449   "FDLR_WAIT",
 450   "FDLW_WAIT",
 451   "FDR_WAIT",
 452   "FDW_WAIT",
 453   "FILE_WAIT",
 454   "POLL_WAIT",
 455   "SELECT_WAIT",
 456   "SLEEP_WAIT",
 457   "WAIT_WAIT",
 458   "SIGSUSPEND",
 459   "SIGWAIT",
 460   "SPINBLOCK",
 461   "JOIN",
 462   "SUSPENDED",
 463   "DEAD",
 464   "DEADLOCK"
 465 };
 466
 467 /* Return a string describing th state of the thread specified by
 468    INFO.  */
 469
 470 static char *
 471 bsd_uthread_extra_thread_info (struct thread_info *info)
 472 {
 473   CORE_ADDR addr = ptid_get_tid (info->ptid);
 474
 475   if (addr != 0)
 476     {
 477       int offset = bsd_uthread_thread_state_offset;
 478       ULONGEST state;
 479
 480       state = read_memory_unsigned_integer (addr + offset, 4);
 481       if (state < ARRAY_SIZE (bsd_uthread_state))
 482         return bsd_uthread_state[state];
 483     }
 484
 485   return NULL;
 486 }
 487
 488 static char *
 489 bsd_uthread_pid_to_str (ptid_t ptid)
 490 {
 491   if (ptid_get_tid (ptid) != 0)
 492     {
 493       static char buf[64];
 494
 495       xsnprintf (buf, sizeof buf, "process %d, thread 0x%lx",
 496                  ptid_get_pid (ptid), ptid_get_tid (ptid));
 497       return buf;
 498     }
 499
 500   return normal_pid_to_str (ptid);
 501 }
 502
 503 struct target_ops *
 504 bsd_uthread_target (void)
 505 {
 506   struct target_ops *t = XZALLOC (struct target_ops);
 507
 508   t->to_shortname = "bsd-uthreads";
 509   t->to_longname = "BSD user-level threads";
 510   t->to_doc = "BSD user-level threads";
 511   t->to_close = bsd_uthread_close;
 512   t->to_mourn_inferior = bsd_uthread_mourn_inferior;
 513   t->to_fetch_registers = bsd_uthread_fetch_registers;
 514   t->to_store_registers = bsd_uthread_store_registers;
 515   t->to_xfer_partial = bsd_uthread_xfer_partial;
 516   t->to_wait = bsd_uthread_wait;
 517   t->to_resume = bsd_uthread_resume;
 518   t->to_thread_alive = bsd_uthread_thread_alive;
 519   t->to_find_new_threads = bsd_uthread_find_new_threads;
 520   t->to_extra_thread_info = bsd_uthread_extra_thread_info;
 521   t->to_pid_to_str = bsd_uthread_pid_to_str;
 522   t->to_stratum = thread_stratum;
 523   t->to_magic = OPS_MAGIC;
 524   bsd_uthread_ops_hack = t;
 525
 526   return t;
 527 }
 528
 529 void
 530 _initialize_bsd_uthread (void)
 531 {
 532   add_target (bsd_uthread_target ());
 533
 534   bsd_uthread_data = gdbarch_data_register_pre_init (bsd_uthread_init);
 535
 536   observer_attach_inferior_created (bsd_uthread_inferior_created);
 537   observer_attach_solib_loaded (bsd_uthread_solib_loaded);
 538   observer_attach_solib_unloaded (bsd_uthread_solib_unloaded);
 539 }