gdb/bsd-uthread.c

   1 /* BSD user-level threads support.
   2
   3    Copyright (C) 2005-2014 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 (struct target_ops *self)
 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 /* Implement the to_xfer_partial target_ops method.  FIXME: This
 335    function is only there because otherwise GDB tries to invoke
 336    deprecate_xfer_memory.  */
 337
 338 static enum target_xfer_status
 339 bsd_uthread_xfer_partial (struct target_ops *ops, enum target_object object,
 340                           const char *annex, gdb_byte *readbuf,
 341                           const gdb_byte *writebuf,
 342                           ULONGEST offset, ULONGEST len, ULONGEST *xfered_len)
 343 {
 344   gdb_assert (ops->beneath->to_xfer_partial);
 345   return ops->beneath->to_xfer_partial (ops->beneath, object, annex, readbuf,
 346                                         writebuf, offset, len, xfered_len);
 347 }
 348
 349 static ptid_t
 350 bsd_uthread_wait (struct target_ops *ops,
 351                   ptid_t ptid, struct target_waitstatus *status, int options)
 352 {
 353   enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
 354   CORE_ADDR addr;
 355   struct target_ops *beneath = find_target_beneath (ops);
 356
 357   /* Pass the request to the layer beneath.  */
 358   ptid = beneath->to_wait (beneath, ptid, status, options);
 359
 360   /* If the process is no longer alive, there's no point in figuring
 361      out the thread ID.  It will fail anyway.  */
 362   if (status->kind == TARGET_WAITKIND_SIGNALLED
 363       || status->kind == TARGET_WAITKIND_EXITED)
 364     return ptid;
 365
 366   /* Fetch the corresponding thread ID, and augment the returned
 367      process ID with it.  */
 368   addr = bsd_uthread_read_memory_address (bsd_uthread_thread_run_addr);
 369   if (addr != 0)
 370     {
 371       gdb_byte buf[4];
 372
 373       /* FIXME: For executables linked statically with the threads
 374          library, we end up here before the program has actually been
 375          executed.  In that case ADDR will be garbage since it has
 376          been read from the wrong virtual memory image.  */
 377       if (target_read_memory (addr, buf, 4) == 0)
 378         {
 379           ULONGEST magic = extract_unsigned_integer (buf, 4, byte_order);
 380           if (magic == BSD_UTHREAD_PTHREAD_MAGIC)
 381             ptid = ptid_build (ptid_get_pid (ptid), 0, addr);
 382         }
 383     }
 384
 385   /* If INFERIOR_PTID doesn't have a tid member yet, and we now have a
 386      ptid with tid set, then ptid is still the initial thread of
 387      the process.  Notify GDB core about it.  */
 388   if (ptid_get_tid (inferior_ptid) == 0
 389       && ptid_get_tid (ptid) != 0 && !in_thread_list (ptid))
 390     thread_change_ptid (inferior_ptid, ptid);
 391
 392   /* Don't let the core see a ptid without a corresponding thread.  */
 393   if (!in_thread_list (ptid) || is_exited (ptid))
 394     add_thread (ptid);
 395
 396   return ptid;
 397 }
 398
 399 static void
 400 bsd_uthread_resume (struct target_ops *ops,
 401                     ptid_t ptid, int step, enum gdb_signal sig)
 402 {
 403   /* Pass the request to the layer beneath.  */
 404   struct target_ops *beneath = find_target_beneath (ops);
 405   beneath->to_resume (beneath, ptid, step, sig);
 406 }
 407
 408 static int
 409 bsd_uthread_thread_alive (struct target_ops *ops, ptid_t ptid)
 410 {
 411   enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
 412   struct target_ops *beneath = find_target_beneath (ops);
 413   CORE_ADDR addr = ptid_get_tid (inferior_ptid);
 414
 415   if (addr != 0)
 416     {
 417       int offset = bsd_uthread_thread_state_offset;
 418       ULONGEST state;
 419
 420       bsd_uthread_check_magic (addr);
 421
 422       state = read_memory_unsigned_integer (addr + offset, 4, byte_order);
 423       if (state == BSD_UTHREAD_PS_DEAD)
 424         return 0;
 425     }
 426
 427   return beneath->to_thread_alive (beneath, ptid);
 428 }
 429
 430 static void
 431 bsd_uthread_find_new_threads (struct target_ops *ops)
 432 {
 433   pid_t pid = ptid_get_pid (inferior_ptid);
 434   int offset = bsd_uthread_thread_next_offset;
 435   CORE_ADDR addr;
 436
 437   addr = bsd_uthread_read_memory_address (bsd_uthread_thread_list_addr);
 438   while (addr != 0)
 439     {
 440       ptid_t ptid = ptid_build (pid, 0, addr);
 441
 442       if (!in_thread_list (ptid) || is_exited (ptid))
 443         {
 444           /* If INFERIOR_PTID doesn't have a tid member yet, then ptid
 445              is still the initial thread of the process.  Notify GDB
 446              core about it.  */
 447           if (ptid_get_tid (inferior_ptid) == 0)
 448             thread_change_ptid (inferior_ptid, ptid);
 449           else
 450             add_thread (ptid);
 451         }
 452
 453       addr = bsd_uthread_read_memory_address (addr + offset);
 454     }
 455 }
 456
 457 /* Possible states a thread can be in.  */
 458 static char *bsd_uthread_state[] =
 459 {
 460   "RUNNING",
 461   "SIGTHREAD",
 462   "MUTEX_WAIT",
 463   "COND_WAIT",
 464   "FDLR_WAIT",
 465   "FDLW_WAIT",
 466   "FDR_WAIT",
 467   "FDW_WAIT",
 468   "FILE_WAIT",
 469   "POLL_WAIT",
 470   "SELECT_WAIT",
 471   "SLEEP_WAIT",
 472   "WAIT_WAIT",
 473   "SIGSUSPEND",
 474   "SIGWAIT",
 475   "SPINBLOCK",
 476   "JOIN",
 477   "SUSPENDED",
 478   "DEAD",
 479   "DEADLOCK"
 480 };
 481
 482 /* Return a string describing th state of the thread specified by
 483    INFO.  */
 484
 485 static char *
 486 bsd_uthread_extra_thread_info (struct target_ops *self,
 487                                struct thread_info *info)
 488 {
 489   enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
 490   CORE_ADDR addr = ptid_get_tid (info->ptid);
 491
 492   if (addr != 0)
 493     {
 494       int offset = bsd_uthread_thread_state_offset;
 495       ULONGEST state;
 496
 497       state = read_memory_unsigned_integer (addr + offset, 4, byte_order);
 498       if (state < ARRAY_SIZE (bsd_uthread_state))
 499         return bsd_uthread_state[state];
 500     }
 501
 502   return NULL;
 503 }
 504
 505 static char *
 506 bsd_uthread_pid_to_str (struct target_ops *ops, ptid_t ptid)
 507 {
 508   if (ptid_get_tid (ptid) != 0)
 509     {
 510       static char buf[64];
 511
 512       xsnprintf (buf, sizeof buf, "process %d, thread 0x%lx",
 513                  ptid_get_pid (ptid), ptid_get_tid (ptid));
 514       return buf;
 515     }
 516
 517   return normal_pid_to_str (ptid);
 518 }
 519
 520 static struct target_ops *
 521 bsd_uthread_target (void)
 522 {
 523   struct target_ops *t = XCNEW (struct target_ops);
 524
 525   t->to_shortname = "bsd-uthreads";
 526   t->to_longname = "BSD user-level threads";
 527   t->to_doc = "BSD user-level threads";
 528   t->to_close = bsd_uthread_close;
 529   t->to_mourn_inferior = bsd_uthread_mourn_inferior;
 530   t->to_fetch_registers = bsd_uthread_fetch_registers;
 531   t->to_store_registers = bsd_uthread_store_registers;
 532   t->to_xfer_partial = bsd_uthread_xfer_partial;
 533   t->to_wait = bsd_uthread_wait;
 534   t->to_resume = bsd_uthread_resume;
 535   t->to_thread_alive = bsd_uthread_thread_alive;
 536   t->to_find_new_threads = bsd_uthread_find_new_threads;
 537   t->to_extra_thread_info = bsd_uthread_extra_thread_info;
 538   t->to_pid_to_str = bsd_uthread_pid_to_str;
 539   t->to_stratum = thread_stratum;
 540   t->to_magic = OPS_MAGIC;
 541   bsd_uthread_ops_hack = t;
 542
 543   return t;
 544 }
 545
 546 /* Provide a prototype to silence -Wmissing-prototypes.  */
 547 extern initialize_file_ftype _initialize_bsd_uthread;
 548
 549 void
 550 _initialize_bsd_uthread (void)
 551 {
 552   complete_target_initialization (bsd_uthread_target ());
 553
 554   bsd_uthread_data = gdbarch_data_register_pre_init (bsd_uthread_init);
 555
 556   observer_attach_inferior_created (bsd_uthread_inferior_created);
 557   observer_attach_solib_loaded (bsd_uthread_solib_loaded);
 558   observer_attach_solib_unloaded (bsd_uthread_solib_unloaded);
 559 }