gdb/bsd-uthread.c

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