gdb/bsd-uthread.c

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