gdb/bsd-uthread.c

   1 /* BSD user-level threads support.
   2
   3    Copyright (C) 2005-2024 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 "extract-store-integer.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 "gdbsupport/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 *, target_wait_flags) 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 struct bsd_uthread_ops
  74 {
  75   /* Supply registers for an inactive thread to a register cache.  */
  76   void (*supply_uthread)(struct regcache *, int, CORE_ADDR) = nullptr;
  77
  78   /* Collect registers for an inactive thread from a register cache.  */
  79   void (*collect_uthread)(const struct regcache *, int, CORE_ADDR) = nullptr;
  80 };
  81
  82 /* Per-architecture data key.  */
  83 static const registry<gdbarch>::key<struct bsd_uthread_ops> bsd_uthread_data;
  84
  85 static struct bsd_uthread_ops *
  86 get_bsd_uthread (struct gdbarch *gdbarch)
  87 {
  88   struct bsd_uthread_ops *ops = bsd_uthread_data.get (gdbarch);
  89   if (ops == nullptr)
  90     ops = bsd_uthread_data.emplace (gdbarch);
  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 = get_bsd_uthread (gdbarch);
 103
 104   ops->supply_uthread = supply_uthread;
 105 }
 106
 107 /* Set the function that collects registers for an inactive thread for
 108    architecture GDBARCH to SUPPLY_UTHREAD.  */
 109
 110 void
 111 bsd_uthread_set_collect_uthread (struct gdbarch *gdbarch,
 112                          void (*collect_uthread) (const struct regcache *,
 113                                                   int, CORE_ADDR))
 114 {
 115   struct bsd_uthread_ops *ops = get_bsd_uthread (gdbarch);
 116
 117   ops->collect_uthread = collect_uthread;
 118 }
 119
 120 /* Magic number to help recognize a valid thread structure.  */
 121 #define BSD_UTHREAD_PTHREAD_MAGIC       0xd09ba115
 122
 123 /* Check whether the thread structure at ADDR is valid.  */
 124
 125 static void
 126 bsd_uthread_check_magic (CORE_ADDR addr)
 127 {
 128   bfd_endian byte_order = gdbarch_byte_order (current_inferior ()->arch ());
 129   ULONGEST magic = read_memory_unsigned_integer (addr, 4, byte_order);
 130
 131   if (magic != BSD_UTHREAD_PTHREAD_MAGIC)
 132     error (_("Bad magic"));
 133 }
 134
 135 /* Thread states.  */
 136 #define BSD_UTHREAD_PS_RUNNING  0
 137 #define BSD_UTHREAD_PS_DEAD     18
 138
 139 /* Address of the pointer to the thread structure for the running
 140    thread.  */
 141 static CORE_ADDR bsd_uthread_thread_run_addr;
 142
 143 /* Address of the list of all threads.  */
 144 static CORE_ADDR bsd_uthread_thread_list_addr;
 145
 146 /* Offsets of various "interesting" bits in the thread structure.  */
 147 static int bsd_uthread_thread_state_offset = -1;
 148 static int bsd_uthread_thread_next_offset = -1;
 149 static int bsd_uthread_thread_ctx_offset;
 150
 151 /* Name of shared threads library.  */
 152 static std::string bsd_uthread_solib_name;
 153
 154 /* Non-zero if the thread stratum implemented by this module is active.  */
 155 static int bsd_uthread_active;
 156
 157 static CORE_ADDR
 158 bsd_uthread_lookup_address (const char *name, struct objfile *objfile)
 159 {
 160   bound_minimal_symbol sym
 161     = lookup_minimal_symbol (current_program_space, name, objfile);
 162   if (sym.minsym)
 163     return sym.value_address ();
 164
 165   return 0;
 166 }
 167
 168 static int
 169 bsd_uthread_lookup_offset (const char *name, struct objfile *objfile)
 170 {
 171   bfd_endian byte_order = gdbarch_byte_order (current_inferior ()->arch ());
 172   CORE_ADDR addr;
 173
 174   addr = bsd_uthread_lookup_address (name, objfile);
 175   if (addr == 0)
 176     return 0;
 177
 178   return read_memory_unsigned_integer (addr, 4, byte_order);
 179 }
 180
 181 static CORE_ADDR
 182 bsd_uthread_read_memory_address (CORE_ADDR addr)
 183 {
 184   type *ptr_type
 185     = builtin_type (current_inferior ()->arch ())->builtin_data_ptr;
 186   return read_memory_typed_address (addr, ptr_type);
 187 }
 188
 189 /* If OBJFILE contains the symbols corresponding to one of the
 190    supported user-level threads libraries, activate the thread stratum
 191    implemented by this module.  */
 192
 193 static int
 194 bsd_uthread_activate (struct objfile *objfile)
 195 {
 196   gdbarch *gdbarch = current_inferior ()->arch ();
 197   struct bsd_uthread_ops *ops = get_bsd_uthread (gdbarch);
 198
 199   /* Skip if the thread stratum has already been activated.  */
 200   if (bsd_uthread_active)
 201     return 0;
 202
 203   /* There's no point in enabling this module if no
 204      architecture-specific operations are provided.  */
 205   if (!ops->supply_uthread)
 206     return 0;
 207
 208   bsd_uthread_thread_run_addr =
 209     bsd_uthread_lookup_address ("_thread_run", objfile);
 210   if (bsd_uthread_thread_run_addr == 0)
 211     return 0;
 212
 213   bsd_uthread_thread_list_addr =
 214     bsd_uthread_lookup_address ("_thread_list", objfile);
 215   if (bsd_uthread_thread_list_addr == 0)
 216     return 0;
 217
 218   bsd_uthread_thread_state_offset =
 219     bsd_uthread_lookup_offset ("_thread_state_offset", objfile);
 220   if (bsd_uthread_thread_state_offset == 0)
 221     return 0;
 222
 223   bsd_uthread_thread_next_offset =
 224     bsd_uthread_lookup_offset ("_thread_next_offset", objfile);
 225   if (bsd_uthread_thread_next_offset == 0)
 226     return 0;
 227
 228   bsd_uthread_thread_ctx_offset =
 229     bsd_uthread_lookup_offset ("_thread_ctx_offset", objfile);
 230
 231   current_inferior ()->push_target (&bsd_uthread_ops);
 232   bsd_uthread_active = 1;
 233   return 1;
 234 }
 235
 236 /* Cleanup due to deactivation.  */
 237
 238 void
 239 bsd_uthread_target::close ()
 240 {
 241   bsd_uthread_active = 0;
 242   bsd_uthread_thread_run_addr = 0;
 243   bsd_uthread_thread_list_addr = 0;
 244   bsd_uthread_thread_state_offset = 0;
 245   bsd_uthread_thread_next_offset = 0;
 246   bsd_uthread_thread_ctx_offset = 0;
 247   bsd_uthread_solib_name.clear ();
 248 }
 249
 250 /* Deactivate the thread stratum implemented by this module.  */
 251
 252 static void
 253 bsd_uthread_deactivate (void)
 254 {
 255   /* Skip if the thread stratum has already been deactivated.  */
 256   if (!bsd_uthread_active)
 257     return;
 258
 259   current_inferior ()->unpush_target (&bsd_uthread_ops);
 260 }
 261
 262 static void
 263 bsd_uthread_inferior_created (inferior *inf)
 264 {
 265   bsd_uthread_activate (NULL);
 266 }
 267
 268 /* Likely candidates for the threads library.  */
 269 static const char * const bsd_uthread_solib_names[] =
 270 {
 271   "/usr/lib/libc_r.so",         /* FreeBSD */
 272   "/usr/lib/libpthread.so",     /* OpenBSD */
 273   NULL
 274 };
 275
 276 static void
 277 bsd_uthread_solib_loaded (solib &so)
 278 {
 279   const char * const *names = bsd_uthread_solib_names;
 280
 281   for (names = bsd_uthread_solib_names; *names; names++)
 282     {
 283       if (startswith (so.so_original_name, *names))
 284         {
 285           solib_read_symbols (so, 0);
 286
 287           if (bsd_uthread_activate (so.objfile))
 288             {
 289               bsd_uthread_solib_name = so.so_original_name;
 290               return;
 291             }
 292         }
 293     }
 294 }
 295
 296 static void
 297 bsd_uthread_solib_unloaded (program_space *pspace, const solib &so)
 298 {
 299   if (bsd_uthread_solib_name.empty ())
 300     return;
 301
 302   if (so.so_original_name == bsd_uthread_solib_name)
 303     bsd_uthread_deactivate ();
 304 }
 305
 306 void
 307 bsd_uthread_target::mourn_inferior ()
 308 {
 309   beneath ()->mourn_inferior ();
 310   bsd_uthread_deactivate ();
 311 }
 312
 313 void
 314 bsd_uthread_target::fetch_registers (struct regcache *regcache, int regnum)
 315 {
 316   struct gdbarch *gdbarch = regcache->arch ();
 317   struct bsd_uthread_ops *uthread_ops = get_bsd_uthread (gdbarch);
 318   ptid_t ptid = regcache->ptid ();
 319   CORE_ADDR addr = ptid.tid ();
 320   CORE_ADDR active_addr;
 321   scoped_restore save_inferior_ptid = make_scoped_restore (&inferior_ptid);
 322
 323   /* We are doing operations (e.g. reading memory) that rely on
 324      inferior_ptid.  */
 325   inferior_ptid = ptid;
 326
 327   /* Always fetch the appropriate registers from the layer beneath.  */
 328   beneath ()->fetch_registers (regcache, regnum);
 329
 330   /* FIXME: That might have gotten us more than we asked for.  Make
 331      sure we overwrite all relevant registers with values from the
 332      thread structure.  This can go once we fix the underlying target.  */
 333   regnum = -1;
 334
 335   active_addr = bsd_uthread_read_memory_address (bsd_uthread_thread_run_addr);
 336   if (addr != 0 && addr != active_addr)
 337     {
 338       bsd_uthread_check_magic (addr);
 339       uthread_ops->supply_uthread (regcache, regnum,
 340                                    addr + bsd_uthread_thread_ctx_offset);
 341     }
 342 }
 343
 344 void
 345 bsd_uthread_target::store_registers (struct regcache *regcache, int regnum)
 346 {
 347   struct gdbarch *gdbarch = regcache->arch ();
 348   struct bsd_uthread_ops *uthread_ops = get_bsd_uthread (gdbarch);
 349   ptid_t ptid = regcache->ptid ();
 350   CORE_ADDR addr = ptid.tid ();
 351   CORE_ADDR active_addr;
 352   scoped_restore save_inferior_ptid = make_scoped_restore (&inferior_ptid);
 353
 354   /* We are doing operations (e.g. reading memory) that rely on
 355      inferior_ptid.  */
 356   inferior_ptid = ptid;
 357
 358   active_addr = bsd_uthread_read_memory_address (bsd_uthread_thread_run_addr);
 359   if (addr != 0 && addr != active_addr)
 360     {
 361       bsd_uthread_check_magic (addr);
 362       uthread_ops->collect_uthread (regcache, regnum,
 363                                     addr + bsd_uthread_thread_ctx_offset);
 364     }
 365   else
 366     {
 367       /* Updating the thread that is currently running; pass the
 368          request to the layer beneath.  */
 369       beneath ()->store_registers (regcache, regnum);
 370     }
 371 }
 372
 373 ptid_t
 374 bsd_uthread_target::wait (ptid_t ptid, struct target_waitstatus *status,
 375                           target_wait_flags options)
 376 {
 377   bfd_endian byte_order = gdbarch_byte_order (current_inferior ()->arch ());
 378   CORE_ADDR addr;
 379   process_stratum_target *beneath
 380     = as_process_stratum_target (this->beneath ());
 381
 382   /* Pass the request to the layer beneath.  */
 383   ptid = beneath->wait (ptid, status, options);
 384
 385   /* If the process is no longer alive, there's no point in figuring
 386      out the thread ID.  It will fail anyway.  */
 387   if (status->kind () == TARGET_WAITKIND_SIGNALLED
 388       || status->kind () == TARGET_WAITKIND_EXITED)
 389     return ptid;
 390
 391   /* Fetch the corresponding thread ID, and augment the returned
 392      process ID with it.  */
 393   addr = bsd_uthread_read_memory_address (bsd_uthread_thread_run_addr);
 394   if (addr != 0)
 395     {
 396       gdb_byte buf[4];
 397
 398       /* FIXME: For executables linked statically with the threads
 399          library, we end up here before the program has actually been
 400          executed.  In that case ADDR will be garbage since it has
 401          been read from the wrong virtual memory image.  */
 402       if (target_read_memory (addr, buf, 4) == 0)
 403         {
 404           ULONGEST magic = extract_unsigned_integer (buf, 4, byte_order);
 405           if (magic == BSD_UTHREAD_PTHREAD_MAGIC)
 406             ptid = ptid_t (ptid.pid (), 0, addr);
 407         }
 408     }
 409
 410   /* If INFERIOR_PTID doesn't have a tid member yet, and we now have a
 411      ptid with tid set, then ptid is still the initial thread of
 412      the process.  Notify GDB core about it.  */
 413   if (inferior_ptid.tid () == 0
 414       && ptid.tid () != 0 && !in_thread_list (beneath, ptid))
 415     thread_change_ptid (beneath, inferior_ptid, ptid);
 416
 417   /* Don't let the core see a ptid without a corresponding thread.  */
 418   thread_info *thread = beneath->find_thread (ptid);
 419   if (thread == NULL || thread->state == THREAD_EXITED)
 420     add_thread (beneath, ptid);
 421
 422   return ptid;
 423 }
 424
 425 void
 426 bsd_uthread_target::resume (ptid_t ptid, int step, enum gdb_signal sig)
 427 {
 428   /* Pass the request to the layer beneath.  */
 429   beneath ()->resume (ptid, step, sig);
 430 }
 431
 432 bool
 433 bsd_uthread_target::thread_alive (ptid_t ptid)
 434 {
 435   bfd_endian byte_order = gdbarch_byte_order (current_inferior ()->arch ());
 436   CORE_ADDR addr = ptid.tid ();
 437
 438   if (addr != 0)
 439     {
 440       int offset = bsd_uthread_thread_state_offset;
 441       ULONGEST state;
 442
 443       bsd_uthread_check_magic (addr);
 444
 445       state = read_memory_unsigned_integer (addr + offset, 4, byte_order);
 446       if (state == BSD_UTHREAD_PS_DEAD)
 447         return false;
 448     }
 449
 450   return beneath ()->thread_alive (ptid);
 451 }
 452
 453 void
 454 bsd_uthread_target::update_thread_list ()
 455 {
 456   pid_t pid = inferior_ptid.pid ();
 457   int offset = bsd_uthread_thread_next_offset;
 458   CORE_ADDR addr;
 459
 460   prune_threads ();
 461
 462   addr = bsd_uthread_read_memory_address (bsd_uthread_thread_list_addr);
 463   while (addr != 0)
 464     {
 465       ptid_t ptid = ptid_t (pid, 0, addr);
 466
 467       process_stratum_target *proc_target
 468         = as_process_stratum_target (this->beneath ());
 469       thread_info *thread = proc_target->find_thread (ptid);
 470       if (thread == nullptr || thread->state == THREAD_EXITED)
 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 (inferior_ptid.tid () == 0)
 476             thread_change_ptid (proc_target, inferior_ptid, ptid);
 477           else
 478             add_thread (proc_target, 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 * const 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   bfd_endian byte_order = gdbarch_byte_order (current_inferior ()->arch ());
 517   CORE_ADDR addr = info->ptid.tid ();
 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 std::string
 533 bsd_uthread_target::pid_to_str (ptid_t ptid)
 534 {
 535   if (ptid.tid () != 0)
 536     return string_printf ("process %d, thread 0x%s",
 537                           ptid.pid (),
 538                           phex_nz (ptid.tid (), sizeof (ULONGEST)));
 539
 540   return normal_pid_to_str (ptid);
 541 }
 542
 543 void _initialize_bsd_uthread ();
 544 void
 545 _initialize_bsd_uthread ()
 546 {
 547   gdb::observers::inferior_created.attach (bsd_uthread_inferior_created,
 548                                            "bsd-uthread");
 549   gdb::observers::solib_loaded.attach (bsd_uthread_solib_loaded,
 550                                        "bsd-uthread");
 551   gdb::observers::solib_unloaded.attach (bsd_uthread_solib_unloaded,
 552                                          "bsd-uthread");
 553 }