gdb/bsd-uthread.c

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