gdb/bsd-uthread.c

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