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