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