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 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 _initialize_bsd_uthread (); 548 void 549 _initialize_bsd_uthread () 550 { 551 bsd_uthread_data = gdbarch_data_register_pre_init (bsd_uthread_init); 552 553 gdb::observers::inferior_created.attach (bsd_uthread_inferior_created); 554 gdb::observers::solib_loaded.attach (bsd_uthread_solib_loaded); 555 gdb::observers::solib_unloaded.attach (bsd_uthread_solib_unloaded); 556 } 557