1/* libthread_db assisted debugging support, generic parts. 2 3 Copyright 1999, 2000, 2001, 2003 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 2 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, write to the Free Software 19 Foundation, Inc., 59 Temple Place - Suite 330, 20 Boston, MA 02111-1307, USA. */ 21 22#include "defs.h" 23 24#include "gdb_assert.h" 25#include <dlfcn.h> 26#include "gdb_proc_service.h" 27#include "gdb_thread_db.h" 28 29#include "bfd.h" 30#include "gdbthread.h" 31#include "inferior.h" 32#include "symfile.h" 33#include "objfiles.h" 34#include "target.h" 35#include "regcache.h" 36#include "solib-svr4.h" 37 38#ifndef LIBTHREAD_DB_SO 39#define LIBTHREAD_DB_SO "libthread_db.so.1" 40#endif 41 42/* If we're running on GNU/Linux, we must explicitly attach to any new 43 threads. */ 44 45/* FIXME: There is certainly some room for improvements: 46 - Cache LWP ids. 47 - Bypass libthread_db when fetching or storing registers for 48 threads bound to a LWP. */ 49 50/* This module's target vector. */ 51static struct target_ops thread_db_ops; 52 53/* The target vector that we call for things this module can't handle. */ 54static struct target_ops *target_beneath; 55 56/* Pointer to the next function on the objfile event chain. */ 57static void (*target_new_objfile_chain) (struct objfile * objfile); 58 59/* Non-zero if we're using this module's target vector. */ 60static int using_thread_db; 61 62/* Non-zero if we have to keep this module's target vector active 63 across re-runs. */ 64static int keep_thread_db; 65 66/* Non-zero if we have determined the signals used by the threads 67 library. */ 68static int thread_signals; 69static sigset_t thread_stop_set; 70static sigset_t thread_print_set; 71 72/* Structure that identifies the child process for the 73 <proc_service.h> interface. */ 74static struct ps_prochandle proc_handle; 75 76/* Connection to the libthread_db library. */ 77static td_thragent_t *thread_agent; 78 79/* Pointers to the libthread_db functions. */ 80 81static td_err_e (*td_init_p) (void); 82 83static td_err_e (*td_ta_new_p) (struct ps_prochandle * ps, 84 td_thragent_t **ta); 85static td_err_e (*td_ta_map_id2thr_p) (const td_thragent_t *ta, thread_t pt, 86 td_thrhandle_t *__th); 87static td_err_e (*td_ta_map_lwp2thr_p) (const td_thragent_t *ta, 88 lwpid_t lwpid, td_thrhandle_t *th); 89static td_err_e (*td_ta_thr_iter_p) (const td_thragent_t *ta, 90 td_thr_iter_f *callback, void *cbdata_p, 91 td_thr_state_e state, int ti_pri, 92 sigset_t *ti_sigmask_p, 93 unsigned int ti_user_flags); 94static td_err_e (*td_ta_event_addr_p) (const td_thragent_t *ta, 95 td_event_e event, td_notify_t *ptr); 96static td_err_e (*td_ta_set_event_p) (const td_thragent_t *ta, 97 td_thr_events_t *event); 98static td_err_e (*td_ta_event_getmsg_p) (const td_thragent_t *ta, 99 td_event_msg_t *msg); 100 101static td_err_e (*td_thr_validate_p) (const td_thrhandle_t *th); 102static td_err_e (*td_thr_get_info_p) (const td_thrhandle_t *th, 103 td_thrinfo_t *infop); 104static td_err_e (*td_thr_getfpregs_p) (const td_thrhandle_t *th, 105 gdb_prfpregset_t *regset); 106static td_err_e (*td_thr_getgregs_p) (const td_thrhandle_t *th, 107 prgregset_t gregs); 108static td_err_e (*td_thr_setfpregs_p) (const td_thrhandle_t *th, 109 const gdb_prfpregset_t *fpregs); 110static td_err_e (*td_thr_setgregs_p) (const td_thrhandle_t *th, 111 prgregset_t gregs); 112static td_err_e (*td_thr_event_enable_p) (const td_thrhandle_t *th, 113 int event); 114 115static td_err_e (*td_thr_tls_get_addr_p) (const td_thrhandle_t *th, 116 void *map_address, 117 size_t offset, void **address); 118 119/* Location of the thread creation event breakpoint. The code at this 120 location in the child process will be called by the pthread library 121 whenever a new thread is created. By setting a special breakpoint 122 at this location, GDB can detect when a new thread is created. We 123 obtain this location via the td_ta_event_addr call. */ 124static CORE_ADDR td_create_bp_addr; 125 126/* Location of the thread death event breakpoint. */ 127static CORE_ADDR td_death_bp_addr; 128 129/* Prototypes for local functions. */ 130static void thread_db_find_new_threads (void); 131static void attach_thread (ptid_t ptid, const td_thrhandle_t *th_p, 132 const td_thrinfo_t *ti_p, int verbose); 133 134 135/* Building process ids. */ 136 137#define GET_PID(ptid) ptid_get_pid (ptid) 138#define GET_LWP(ptid) ptid_get_lwp (ptid) 139#define GET_THREAD(ptid) ptid_get_tid (ptid) 140 141#define is_lwp(ptid) (GET_LWP (ptid) != 0) 142#define is_thread(ptid) (GET_THREAD (ptid) != 0) 143 144#define BUILD_LWP(lwp, pid) ptid_build (pid, lwp, 0) 145#define BUILD_THREAD(tid, pid) ptid_build (pid, 0, tid) 146 147 148/* Use "struct private_thread_info" to cache thread state. This is 149 a substantial optimization. */ 150 151struct private_thread_info 152{ 153 /* Cached thread state. */ 154 unsigned int th_valid:1; 155 unsigned int ti_valid:1; 156 157 td_thrhandle_t th; 158 td_thrinfo_t ti; 159}; 160 161 162static char * 163thread_db_err_str (td_err_e err) 164{ 165 static char buf[64]; 166 167 switch (err) 168 { 169 case TD_OK: 170 return "generic 'call succeeded'"; 171 case TD_ERR: 172 return "generic error"; 173 case TD_NOTHR: 174 return "no thread to satisfy query"; 175 case TD_NOSV: 176 return "no sync handle to satisfy query"; 177 case TD_NOLWP: 178 return "no LWP to satisfy query"; 179 case TD_BADPH: 180 return "invalid process handle"; 181 case TD_BADTH: 182 return "invalid thread handle"; 183 case TD_BADSH: 184 return "invalid synchronization handle"; 185 case TD_BADTA: 186 return "invalid thread agent"; 187 case TD_BADKEY: 188 return "invalid key"; 189 case TD_NOMSG: 190 return "no event message for getmsg"; 191 case TD_NOFPREGS: 192 return "FPU register set not available"; 193 case TD_NOLIBTHREAD: 194 return "application not linked with libthread"; 195 case TD_NOEVENT: 196 return "requested event is not supported"; 197 case TD_NOCAPAB: 198 return "capability not available"; 199 case TD_DBERR: 200 return "debugger service failed"; 201 case TD_NOAPLIC: 202 return "operation not applicable to"; 203 case TD_NOTSD: 204 return "no thread-specific data for this thread"; 205 case TD_MALLOC: 206 return "malloc failed"; 207 case TD_PARTIALREG: 208 return "only part of register set was written/read"; 209 case TD_NOXREGS: 210 return "X register set not available for this thread"; 211 default: 212 snprintf (buf, sizeof (buf), "unknown thread_db error '%d'", err); 213 return buf; 214 } 215} 216 217static char * 218thread_db_state_str (td_thr_state_e state) 219{ 220 static char buf[64]; 221 222 switch (state) 223 { 224 case TD_THR_STOPPED: 225 return "stopped by debugger"; 226 case TD_THR_RUN: 227 return "runnable"; 228 case TD_THR_ACTIVE: 229 return "active"; 230 case TD_THR_ZOMBIE: 231 return "zombie"; 232 case TD_THR_SLEEP: 233 return "sleeping"; 234 case TD_THR_STOPPED_ASLEEP: 235 return "stopped by debugger AND blocked"; 236 default: 237 snprintf (buf, sizeof (buf), "unknown thread_db state %d", state); 238 return buf; 239 } 240} 241 242/* A callback function for td_ta_thr_iter, which we use to map all 243 threads to LWPs. 244 245 THP is a handle to the current thread; if INFOP is not NULL, the 246 struct thread_info associated with this thread is returned in 247 *INFOP. */ 248 249static int 250thread_get_info_callback (const td_thrhandle_t *thp, void *infop) 251{ 252 td_thrinfo_t ti; 253 td_err_e err; 254 struct thread_info *thread_info; 255 ptid_t thread_ptid; 256 257 err = td_thr_get_info_p (thp, &ti); 258 if (err != TD_OK) 259 error ("thread_get_info_callback: cannot get thread info: %s", 260 thread_db_err_str (err)); 261 262 /* Fill the cache. */ 263 thread_ptid = BUILD_THREAD (ti.ti_tid, GET_PID (inferior_ptid)); 264 thread_info = find_thread_pid (thread_ptid); 265 266 if (thread_info == NULL) 267 { 268 /* New thread. Attach to it now (why wait?). */ 269 attach_thread (thread_ptid, thp, &ti, 1); 270 thread_info = find_thread_pid (thread_ptid); 271 gdb_assert (thread_info != NULL); 272 } 273 274 memcpy (&thread_info->private->th, thp, sizeof (*thp)); 275 thread_info->private->th_valid = 1; 276 memcpy (&thread_info->private->ti, &ti, sizeof (ti)); 277 thread_info->private->ti_valid = 1; 278 279 if (infop != NULL) 280 *(struct thread_info **) infop = thread_info; 281 282 return 0; 283} 284 285/* Accessor functions for the thread_db information, with caching. */ 286 287static void 288thread_db_map_id2thr (struct thread_info *thread_info, int fatal) 289{ 290 td_err_e err; 291 292 if (thread_info->private->th_valid) 293 return; 294 295 err = td_ta_map_id2thr_p (thread_agent, GET_THREAD (thread_info->ptid), 296 &thread_info->private->th); 297 if (err != TD_OK) 298 { 299 if (fatal) 300 error ("Cannot find thread %ld: %s", 301 (long) GET_THREAD (thread_info->ptid), 302 thread_db_err_str (err)); 303 } 304 else 305 thread_info->private->th_valid = 1; 306} 307 308static td_thrinfo_t * 309thread_db_get_info (struct thread_info *thread_info) 310{ 311 td_err_e err; 312 313 if (thread_info->private->ti_valid) 314 return &thread_info->private->ti; 315 316 if (!thread_info->private->th_valid) 317 thread_db_map_id2thr (thread_info, 1); 318 319 err = 320 td_thr_get_info_p (&thread_info->private->th, &thread_info->private->ti); 321 if (err != TD_OK) 322 error ("thread_db_get_info: cannot get thread info: %s", 323 thread_db_err_str (err)); 324 325 thread_info->private->ti_valid = 1; 326 return &thread_info->private->ti; 327} 328 329/* Convert between user-level thread ids and LWP ids. */ 330 331static ptid_t 332thread_from_lwp (ptid_t ptid) 333{ 334 td_thrhandle_t th; 335 td_err_e err; 336 struct thread_info *thread_info; 337 ptid_t thread_ptid; 338 339 if (GET_LWP (ptid) == 0) 340 ptid = BUILD_LWP (GET_PID (ptid), GET_PID (ptid)); 341 342 gdb_assert (is_lwp (ptid)); 343 344 err = td_ta_map_lwp2thr_p (thread_agent, GET_LWP (ptid), &th); 345 if (err != TD_OK) 346 error ("Cannot find user-level thread for LWP %ld: %s", 347 GET_LWP (ptid), thread_db_err_str (err)); 348 349 thread_info = NULL; 350 thread_get_info_callback (&th, &thread_info); 351 gdb_assert (thread_info && thread_info->private->ti_valid); 352 353 return BUILD_THREAD (thread_info->private->ti.ti_tid, GET_PID (ptid)); 354} 355 356static ptid_t 357lwp_from_thread (ptid_t ptid) 358{ 359 struct thread_info *thread_info; 360 ptid_t thread_ptid; 361 362 if (!is_thread (ptid)) 363 return ptid; 364 365 thread_info = find_thread_pid (ptid); 366 thread_db_get_info (thread_info); 367 368 return BUILD_LWP (thread_info->private->ti.ti_lid, GET_PID (ptid)); 369} 370 371 372void 373thread_db_init (struct target_ops *target) 374{ 375 target_beneath = target; 376} 377 378static void * 379verbose_dlsym (void *handle, const char *name) 380{ 381 void *sym = dlsym (handle, name); 382 if (sym == NULL) 383 warning ("Symbol \"%s\" not found in libthread_db: %s", name, dlerror ()); 384 return sym; 385} 386 387static int 388thread_db_load (void) 389{ 390 void *handle; 391 td_err_e err; 392 393 handle = dlopen (LIBTHREAD_DB_SO, RTLD_NOW); 394 if (handle == NULL) 395 { 396 fprintf_filtered (gdb_stderr, "\n\ndlopen failed on '%s' - %s\n", 397 LIBTHREAD_DB_SO, dlerror ()); 398 fprintf_filtered (gdb_stderr, 399 "GDB will not be able to debug pthreads.\n\n"); 400 return 0; 401 } 402 403 /* Initialize pointers to the dynamic library functions we will use. 404 Essential functions first. */ 405 406 td_init_p = verbose_dlsym (handle, "td_init"); 407 if (td_init_p == NULL) 408 return 0; 409 410 td_ta_new_p = verbose_dlsym (handle, "td_ta_new"); 411 if (td_ta_new_p == NULL) 412 return 0; 413 414 td_ta_map_id2thr_p = verbose_dlsym (handle, "td_ta_map_id2thr"); 415 if (td_ta_map_id2thr_p == NULL) 416 return 0; 417 418 td_ta_map_lwp2thr_p = verbose_dlsym (handle, "td_ta_map_lwp2thr"); 419 if (td_ta_map_lwp2thr_p == NULL) 420 return 0; 421 422 td_ta_thr_iter_p = verbose_dlsym (handle, "td_ta_thr_iter"); 423 if (td_ta_thr_iter_p == NULL) 424 return 0; 425 426 td_thr_validate_p = verbose_dlsym (handle, "td_thr_validate"); 427 if (td_thr_validate_p == NULL) 428 return 0; 429 430 td_thr_get_info_p = verbose_dlsym (handle, "td_thr_get_info"); 431 if (td_thr_get_info_p == NULL) 432 return 0; 433 434 td_thr_getfpregs_p = verbose_dlsym (handle, "td_thr_getfpregs"); 435 if (td_thr_getfpregs_p == NULL) 436 return 0; 437 438 td_thr_getgregs_p = verbose_dlsym (handle, "td_thr_getgregs"); 439 if (td_thr_getgregs_p == NULL) 440 return 0; 441 442 td_thr_setfpregs_p = verbose_dlsym (handle, "td_thr_setfpregs"); 443 if (td_thr_setfpregs_p == NULL) 444 return 0; 445 446 td_thr_setgregs_p = verbose_dlsym (handle, "td_thr_setgregs"); 447 if (td_thr_setgregs_p == NULL) 448 return 0; 449 450 /* Initialize the library. */ 451 err = td_init_p (); 452 if (err != TD_OK) 453 { 454 warning ("Cannot initialize libthread_db: %s", thread_db_err_str (err)); 455 return 0; 456 } 457 458 /* These are not essential. */ 459 td_ta_event_addr_p = dlsym (handle, "td_ta_event_addr"); 460 td_ta_set_event_p = dlsym (handle, "td_ta_set_event"); 461 td_ta_event_getmsg_p = dlsym (handle, "td_ta_event_getmsg"); 462 td_thr_event_enable_p = dlsym (handle, "td_thr_event_enable"); 463 td_thr_tls_get_addr_p = dlsym (handle, "td_thr_tls_get_addr"); 464 465 return 1; 466} 467 468static td_err_e 469enable_thread_event (td_thragent_t *thread_agent, int event, CORE_ADDR *bp) 470{ 471 td_notify_t notify; 472 td_err_e err; 473 474 /* Get the breakpoint address for thread EVENT. */ 475 err = td_ta_event_addr_p (thread_agent, event, ¬ify); 476 if (err != TD_OK) 477 return err; 478 479 /* Set up the breakpoint. */ 480 (*bp) = gdbarch_convert_from_func_ptr_addr (current_gdbarch, 481 (CORE_ADDR) notify.u.bptaddr, 482 ¤t_target); 483 create_thread_event_breakpoint ((*bp)); 484 485 return TD_OK; 486} 487 488static void 489enable_thread_event_reporting (void) 490{ 491 td_thr_events_t events; 492 td_notify_t notify; 493 td_err_e err; 494 495 /* We cannot use the thread event reporting facility if these 496 functions aren't available. */ 497 if (td_ta_event_addr_p == NULL || td_ta_set_event_p == NULL 498 || td_ta_event_getmsg_p == NULL || td_thr_event_enable_p == NULL) 499 return; 500 501 /* Set the process wide mask saying which events we're interested in. */ 502 td_event_emptyset (&events); 503 td_event_addset (&events, TD_CREATE); 504#if 0 505 /* FIXME: kettenis/2000-04-23: The event reporting facility is 506 broken for TD_DEATH events in glibc 2.1.3, so don't enable it for 507 now. */ 508 td_event_addset (&events, TD_DEATH); 509#endif 510 511 err = td_ta_set_event_p (thread_agent, &events); 512 if (err != TD_OK) 513 { 514 warning ("Unable to set global thread event mask: %s", 515 thread_db_err_str (err)); 516 return; 517 } 518 519 /* Delete previous thread event breakpoints, if any. */ 520 remove_thread_event_breakpoints (); 521 td_create_bp_addr = 0; 522 td_death_bp_addr = 0; 523 524 /* Set up the thread creation event. */ 525 err = enable_thread_event (thread_agent, TD_CREATE, &td_create_bp_addr); 526 if (err != TD_OK) 527 { 528 warning ("Unable to get location for thread creation breakpoint: %s", 529 thread_db_err_str (err)); 530 return; 531 } 532 533 /* Set up the thread death event. */ 534 err = enable_thread_event (thread_agent, TD_DEATH, &td_death_bp_addr); 535 if (err != TD_OK) 536 { 537 warning ("Unable to get location for thread death breakpoint: %s", 538 thread_db_err_str (err)); 539 return; 540 } 541} 542 543static void 544disable_thread_event_reporting (void) 545{ 546 td_thr_events_t events; 547 548 /* Set the process wide mask saying we aren't interested in any 549 events anymore. */ 550 td_event_emptyset (&events); 551 td_ta_set_event_p (thread_agent, &events); 552 553 /* Delete thread event breakpoints, if any. */ 554 remove_thread_event_breakpoints (); 555 td_create_bp_addr = 0; 556 td_death_bp_addr = 0; 557} 558 559static void 560check_thread_signals (void) 561{ 562#ifdef GET_THREAD_SIGNALS 563 if (!thread_signals) 564 { 565 sigset_t mask; 566 int i; 567 568 GET_THREAD_SIGNALS (&mask); 569 sigemptyset (&thread_stop_set); 570 sigemptyset (&thread_print_set); 571 572 for (i = 1; i < NSIG; i++) 573 { 574 if (sigismember (&mask, i)) 575 { 576 if (signal_stop_update (target_signal_from_host (i), 0)) 577 sigaddset (&thread_stop_set, i); 578 if (signal_print_update (target_signal_from_host (i), 0)) 579 sigaddset (&thread_print_set, i); 580 thread_signals = 1; 581 } 582 } 583 } 584#endif 585} 586 587static void 588thread_db_new_objfile (struct objfile *objfile) 589{ 590 td_err_e err; 591 592 /* First time through, report that libthread_db was successfuly 593 loaded. Can't print this in in thread_db_load as, at that stage, 594 the interpreter and it's console haven't started. The real 595 problem here is that libthread_db is loaded too early - it should 596 only be loaded when there is a program to debug. */ 597 { 598 static int dejavu; 599 if (!dejavu) 600 { 601 Dl_info info; 602 const char *library = NULL; 603 /* Try dladdr. */ 604 if (dladdr ((*td_ta_new_p), &info) != 0) 605 library = info.dli_fname; 606 /* Try dlinfo? */ 607 if (library == NULL) 608 /* Paranoid - don't let a NULL path slip through. */ 609 library = LIBTHREAD_DB_SO; 610 printf_unfiltered ("Using host libthread_db library \"%s\".\n", 611 library); 612 dejavu = 1; 613 } 614 } 615 616 /* Don't attempt to use thread_db on targets which can not run 617 (core files). */ 618 if (objfile == NULL || !target_has_execution) 619 { 620 /* All symbols have been discarded. If the thread_db target is 621 active, deactivate it now. */ 622 if (using_thread_db) 623 { 624 gdb_assert (proc_handle.pid == 0); 625 unpush_target (&thread_db_ops); 626 using_thread_db = 0; 627 } 628 629 keep_thread_db = 0; 630 631 goto quit; 632 } 633 634 if (using_thread_db) 635 /* Nothing to do. The thread library was already detected and the 636 target vector was already activated. */ 637 goto quit; 638 639 /* Initialize the structure that identifies the child process. Note 640 that at this point there is no guarantee that we actually have a 641 child process. */ 642 proc_handle.pid = GET_PID (inferior_ptid); 643 644 /* Now attempt to open a connection to the thread library. */ 645 err = td_ta_new_p (&proc_handle, &thread_agent); 646 switch (err) 647 { 648 case TD_NOLIBTHREAD: 649 /* No thread library was detected. */ 650 break; 651 652 case TD_OK: 653 printf_unfiltered ("[Thread debugging using libthread_db enabled]\n"); 654 655 /* The thread library was detected. Activate the thread_db target. */ 656 push_target (&thread_db_ops); 657 using_thread_db = 1; 658 659 /* If the thread library was detected in the main symbol file 660 itself, we assume that the program was statically linked 661 against the thread library and well have to keep this 662 module's target vector activated until forever... Well, at 663 least until all symbols have been discarded anyway (see 664 above). */ 665 if (objfile == symfile_objfile) 666 { 667 gdb_assert (proc_handle.pid == 0); 668 keep_thread_db = 1; 669 } 670 671 /* We can only poke around if there actually is a child process. 672 If there is no child process alive, postpone the steps below 673 until one has been created. */ 674 if (proc_handle.pid != 0) 675 { 676 enable_thread_event_reporting (); 677 thread_db_find_new_threads (); 678 } 679 break; 680 681 default: 682 warning ("Cannot initialize thread debugging library: %s", 683 thread_db_err_str (err)); 684 break; 685 } 686 687quit: 688 if (target_new_objfile_chain) 689 target_new_objfile_chain (objfile); 690} 691 692static void 693attach_thread (ptid_t ptid, const td_thrhandle_t *th_p, 694 const td_thrinfo_t *ti_p, int verbose) 695{ 696 struct thread_info *tp; 697 td_err_e err; 698 699 check_thread_signals (); 700 701 /* Add the thread to GDB's thread list. */ 702 tp = add_thread (ptid); 703 tp->private = xmalloc (sizeof (struct private_thread_info)); 704 memset (tp->private, 0, sizeof (struct private_thread_info)); 705 706 if (verbose) 707 printf_unfiltered ("[New %s]\n", target_pid_to_str (ptid)); 708 709 if (ti_p->ti_state == TD_THR_UNKNOWN || ti_p->ti_state == TD_THR_ZOMBIE) 710 return; /* A zombie thread -- do not attach. */ 711 712 /* Under GNU/Linux, we have to attach to each and every thread. */ 713#ifdef ATTACH_LWP 714 ATTACH_LWP (BUILD_LWP (ti_p->ti_lid, GET_PID (ptid)), 0); 715#endif 716 717 /* Enable thread event reporting for this thread. */ 718 err = td_thr_event_enable_p (th_p, 1); 719 if (err != TD_OK) 720 error ("Cannot enable thread event reporting for %s: %s", 721 target_pid_to_str (ptid), thread_db_err_str (err)); 722} 723 724static void 725thread_db_attach (char *args, int from_tty) 726{ 727 target_beneath->to_attach (args, from_tty); 728 729 /* Destroy thread info; it's no longer valid. */ 730 init_thread_list (); 731 732 /* The child process is now the actual multi-threaded 733 program. Snatch its process ID... */ 734 proc_handle.pid = GET_PID (inferior_ptid); 735 736 /* ...and perform the remaining initialization steps. */ 737 enable_thread_event_reporting (); 738 thread_db_find_new_threads (); 739} 740 741static void 742detach_thread (ptid_t ptid, int verbose) 743{ 744 if (verbose) 745 printf_unfiltered ("[%s exited]\n", target_pid_to_str (ptid)); 746} 747 748static void 749thread_db_detach (char *args, int from_tty) 750{ 751 disable_thread_event_reporting (); 752 753 /* There's no need to save & restore inferior_ptid here, since the 754 inferior is supposed to be survive this function call. */ 755 inferior_ptid = lwp_from_thread (inferior_ptid); 756 757 /* Forget about the child's process ID. We shouldn't need it 758 anymore. */ 759 proc_handle.pid = 0; 760 761 target_beneath->to_detach (args, from_tty); 762} 763 764static int 765clear_lwpid_callback (struct thread_info *thread, void *dummy) 766{ 767 /* If we know that our thread implementation is 1-to-1, we could save 768 a certain amount of information; it's not clear how much, so we 769 are always conservative. */ 770 771 thread->private->th_valid = 0; 772 thread->private->ti_valid = 0; 773 774 return 0; 775} 776 777static void 778thread_db_resume (ptid_t ptid, int step, enum target_signal signo) 779{ 780 struct cleanup *old_chain = save_inferior_ptid (); 781 782 if (GET_PID (ptid) == -1) 783 inferior_ptid = lwp_from_thread (inferior_ptid); 784 else if (is_thread (ptid)) 785 ptid = lwp_from_thread (ptid); 786 787 /* Clear cached data which may not be valid after the resume. */ 788 iterate_over_threads (clear_lwpid_callback, NULL); 789 790 target_beneath->to_resume (ptid, step, signo); 791 792 do_cleanups (old_chain); 793} 794 795/* Check if PID is currently stopped at the location of a thread event 796 breakpoint location. If it is, read the event message and act upon 797 the event. */ 798 799static void 800check_event (ptid_t ptid) 801{ 802 td_event_msg_t msg; 803 td_thrinfo_t ti; 804 td_err_e err; 805 CORE_ADDR stop_pc; 806 int loop = 0; 807 808 /* Bail out early if we're not at a thread event breakpoint. */ 809 stop_pc = read_pc_pid (ptid) - DECR_PC_AFTER_BREAK; 810 if (stop_pc != td_create_bp_addr && stop_pc != td_death_bp_addr) 811 return; 812 813 /* If we are at a create breakpoint, we do not know what new lwp 814 was created and cannot specifically locate the event message for it. 815 We have to call td_ta_event_getmsg() to get 816 the latest message. Since we have no way of correlating whether 817 the event message we get back corresponds to our breakpoint, we must 818 loop and read all event messages, processing them appropriately. 819 This guarantees we will process the correct message before continuing 820 from the breakpoint. 821 822 Currently, death events are not enabled. If they are enabled, 823 the death event can use the td_thr_event_getmsg() interface to 824 get the message specifically for that lwp and avoid looping 825 below. */ 826 827 loop = 1; 828 829 do 830 { 831 err = td_ta_event_getmsg_p (thread_agent, &msg); 832 if (err != TD_OK) 833 { 834 if (err == TD_NOMSG) 835 return; 836 837 error ("Cannot get thread event message: %s", 838 thread_db_err_str (err)); 839 } 840 841 err = td_thr_get_info_p (msg.th_p, &ti); 842 if (err != TD_OK) 843 error ("Cannot get thread info: %s", thread_db_err_str (err)); 844 845 ptid = BUILD_THREAD (ti.ti_tid, GET_PID (ptid)); 846 847 switch (msg.event) 848 { 849 case TD_CREATE: 850 851 /* We may already know about this thread, for instance when the 852 user has issued the `info threads' command before the SIGTRAP 853 for hitting the thread creation breakpoint was reported. */ 854 if (!in_thread_list (ptid)) 855 attach_thread (ptid, msg.th_p, &ti, 1); 856 857 break; 858 859 case TD_DEATH: 860 861 if (!in_thread_list (ptid)) 862 error ("Spurious thread death event."); 863 864 detach_thread (ptid, 1); 865 866 break; 867 868 default: 869 error ("Spurious thread event."); 870 } 871 } 872 while (loop); 873} 874 875static ptid_t 876thread_db_wait (ptid_t ptid, struct target_waitstatus *ourstatus) 877{ 878 extern ptid_t trap_ptid; 879 880 if (GET_PID (ptid) != -1 && is_thread (ptid)) 881 ptid = lwp_from_thread (ptid); 882 883 ptid = target_beneath->to_wait (ptid, ourstatus); 884 885 if (proc_handle.pid == 0) 886 /* The current child process isn't the actual multi-threaded 887 program yet, so don't try to do any special thread-specific 888 post-processing and bail out early. */ 889 return ptid; 890 891 if (ourstatus->kind == TARGET_WAITKIND_EXITED) 892 return pid_to_ptid (-1); 893 894 if (ourstatus->kind == TARGET_WAITKIND_STOPPED 895 && ourstatus->value.sig == TARGET_SIGNAL_TRAP) 896 /* Check for a thread event. */ 897 check_event (ptid); 898 899 if (!ptid_equal (trap_ptid, null_ptid)) 900 trap_ptid = thread_from_lwp (trap_ptid); 901 902 return thread_from_lwp (ptid); 903} 904 905static int 906thread_db_xfer_memory (CORE_ADDR memaddr, char *myaddr, int len, int write, 907 struct mem_attrib *attrib, struct target_ops *target) 908{ 909 struct cleanup *old_chain = save_inferior_ptid (); 910 int xfer; 911 912 if (is_thread (inferior_ptid)) 913 { 914 /* FIXME: This seems to be necessary to make sure breakpoints 915 are removed. */ 916 if (!target_thread_alive (inferior_ptid)) 917 inferior_ptid = pid_to_ptid (GET_PID (inferior_ptid)); 918 else 919 inferior_ptid = lwp_from_thread (inferior_ptid); 920 } 921 922 xfer = 923 target_beneath->to_xfer_memory (memaddr, myaddr, len, write, attrib, 924 target); 925 926 do_cleanups (old_chain); 927 return xfer; 928} 929 930static void 931thread_db_fetch_registers (int regno) 932{ 933 struct thread_info *thread_info; 934 prgregset_t gregset; 935 gdb_prfpregset_t fpregset; 936 td_err_e err; 937 938 if (!is_thread (inferior_ptid)) 939 { 940 /* Pass the request to the target beneath us. */ 941 target_beneath->to_fetch_registers (regno); 942 return; 943 } 944 945 thread_info = find_thread_pid (inferior_ptid); 946 thread_db_map_id2thr (thread_info, 1); 947 948 err = td_thr_getgregs_p (&thread_info->private->th, gregset); 949 if (err != TD_OK) 950 error ("Cannot fetch general-purpose registers for thread %ld: %s", 951 (long) GET_THREAD (inferior_ptid), thread_db_err_str (err)); 952 953 err = td_thr_getfpregs_p (&thread_info->private->th, &fpregset); 954 if (err != TD_OK) 955 error ("Cannot get floating-point registers for thread %ld: %s", 956 (long) GET_THREAD (inferior_ptid), thread_db_err_str (err)); 957 958 /* Note that we must call supply_gregset after calling the thread_db 959 routines because the thread_db routines call ps_lgetgregs and 960 friends which clobber GDB's register cache. */ 961 supply_gregset ((gdb_gregset_t *) gregset); 962 supply_fpregset (&fpregset); 963} 964 965static void 966thread_db_store_registers (int regno) 967{ 968 prgregset_t gregset; 969 gdb_prfpregset_t fpregset; 970 td_err_e err; 971 struct thread_info *thread_info; 972 973 if (!is_thread (inferior_ptid)) 974 { 975 /* Pass the request to the target beneath us. */ 976 target_beneath->to_store_registers (regno); 977 return; 978 } 979 980 thread_info = find_thread_pid (inferior_ptid); 981 thread_db_map_id2thr (thread_info, 1); 982 983 if (regno != -1) 984 { 985 char raw[MAX_REGISTER_SIZE]; 986 987 deprecated_read_register_gen (regno, raw); 988 thread_db_fetch_registers (-1); 989 supply_register (regno, raw); 990 } 991 992 fill_gregset ((gdb_gregset_t *) gregset, -1); 993 fill_fpregset (&fpregset, -1); 994 995 err = td_thr_setgregs_p (&thread_info->private->th, gregset); 996 if (err != TD_OK) 997 error ("Cannot store general-purpose registers for thread %ld: %s", 998 (long) GET_THREAD (inferior_ptid), thread_db_err_str (err)); 999 err = td_thr_setfpregs_p (&thread_info->private->th, &fpregset); 1000 if (err != TD_OK) 1001 error ("Cannot store floating-point registers for thread %ld: %s", 1002 (long) GET_THREAD (inferior_ptid), thread_db_err_str (err)); 1003} 1004 1005static void 1006thread_db_kill (void) 1007{ 1008 /* There's no need to save & restore inferior_ptid here, since the 1009 inferior isn't supposed to survive this function call. */ 1010 inferior_ptid = lwp_from_thread (inferior_ptid); 1011 target_beneath->to_kill (); 1012} 1013 1014static void 1015thread_db_create_inferior (char *exec_file, char *allargs, char **env) 1016{ 1017 if (!keep_thread_db) 1018 { 1019 unpush_target (&thread_db_ops); 1020 using_thread_db = 0; 1021 } 1022 1023 target_beneath->to_create_inferior (exec_file, allargs, env); 1024} 1025 1026static void 1027thread_db_post_startup_inferior (ptid_t ptid) 1028{ 1029 if (proc_handle.pid == 0) 1030 { 1031 /* The child process is now the actual multi-threaded 1032 program. Snatch its process ID... */ 1033 proc_handle.pid = GET_PID (ptid); 1034 1035 /* ...and perform the remaining initialization steps. */ 1036 enable_thread_event_reporting (); 1037 thread_db_find_new_threads (); 1038 } 1039} 1040 1041static void 1042thread_db_mourn_inferior (void) 1043{ 1044 remove_thread_event_breakpoints (); 1045 1046 /* Forget about the child's process ID. We shouldn't need it 1047 anymore. */ 1048 proc_handle.pid = 0; 1049 1050 target_beneath->to_mourn_inferior (); 1051 1052 /* Detach thread_db target ops if not dealing with a statically 1053 linked threaded program. This allows a corefile to be debugged 1054 after finishing debugging of a threaded program. At present, 1055 debugging a statically-linked threaded program is broken, but 1056 the check is added below in the event that it is fixed in the 1057 future. */ 1058 if (!keep_thread_db) 1059 { 1060 unpush_target (&thread_db_ops); 1061 using_thread_db = 0; 1062 } 1063} 1064 1065static int 1066thread_db_thread_alive (ptid_t ptid) 1067{ 1068 td_thrhandle_t th; 1069 td_err_e err; 1070 1071 if (is_thread (ptid)) 1072 { 1073 struct thread_info *thread_info; 1074 thread_info = find_thread_pid (ptid); 1075 1076 thread_db_map_id2thr (thread_info, 0); 1077 if (!thread_info->private->th_valid) 1078 return 0; 1079 1080 err = td_thr_validate_p (&thread_info->private->th); 1081 if (err != TD_OK) 1082 return 0; 1083 1084 if (!thread_info->private->ti_valid) 1085 { 1086 err = 1087 td_thr_get_info_p (&thread_info->private->th, 1088 &thread_info->private->ti); 1089 if (err != TD_OK) 1090 return 0; 1091 thread_info->private->ti_valid = 1; 1092 } 1093 1094 if (thread_info->private->ti.ti_state == TD_THR_UNKNOWN 1095 || thread_info->private->ti.ti_state == TD_THR_ZOMBIE) 1096 return 0; /* A zombie thread. */ 1097 1098 return 1; 1099 } 1100 1101 if (target_beneath->to_thread_alive) 1102 return target_beneath->to_thread_alive (ptid); 1103 1104 return 0; 1105} 1106 1107static int 1108find_new_threads_callback (const td_thrhandle_t *th_p, void *data) 1109{ 1110 td_thrinfo_t ti; 1111 td_err_e err; 1112 ptid_t ptid; 1113 1114 err = td_thr_get_info_p (th_p, &ti); 1115 if (err != TD_OK) 1116 error ("find_new_threads_callback: cannot get thread info: %s", 1117 thread_db_err_str (err)); 1118 1119 if (ti.ti_state == TD_THR_UNKNOWN || ti.ti_state == TD_THR_ZOMBIE) 1120 return 0; /* A zombie -- ignore. */ 1121 1122 ptid = BUILD_THREAD (ti.ti_tid, GET_PID (inferior_ptid)); 1123 1124 if (!in_thread_list (ptid)) 1125 attach_thread (ptid, th_p, &ti, 1); 1126 1127 return 0; 1128} 1129 1130static void 1131thread_db_find_new_threads (void) 1132{ 1133 td_err_e err; 1134 1135 /* Iterate over all user-space threads to discover new threads. */ 1136 err = td_ta_thr_iter_p (thread_agent, find_new_threads_callback, NULL, 1137 TD_THR_ANY_STATE, TD_THR_LOWEST_PRIORITY, 1138 TD_SIGNO_MASK, TD_THR_ANY_USER_FLAGS); 1139 if (err != TD_OK) 1140 error ("Cannot find new threads: %s", thread_db_err_str (err)); 1141} 1142 1143static char * 1144thread_db_pid_to_str (ptid_t ptid) 1145{ 1146 if (is_thread (ptid)) 1147 { 1148 static char buf[64]; 1149 td_thrinfo_t *ti_p; 1150 td_err_e err; 1151 struct thread_info *thread_info; 1152 1153 thread_info = find_thread_pid (ptid); 1154 thread_db_map_id2thr (thread_info, 0); 1155 if (!thread_info->private->th_valid) 1156 { 1157 snprintf (buf, sizeof (buf), "Thread %ld (Missing)", 1158 GET_THREAD (ptid)); 1159 return buf; 1160 } 1161 1162 ti_p = thread_db_get_info (thread_info); 1163 1164 if (ti_p->ti_state == TD_THR_ACTIVE && ti_p->ti_lid != 0) 1165 { 1166 snprintf (buf, sizeof (buf), "Thread %ld (LWP %d)", 1167 (long) ti_p->ti_tid, ti_p->ti_lid); 1168 } 1169 else 1170 { 1171 snprintf (buf, sizeof (buf), "Thread %ld (%s)", 1172 (long) ti_p->ti_tid, 1173 thread_db_state_str (ti_p->ti_state)); 1174 } 1175 1176 return buf; 1177 } 1178 1179 if (target_beneath->to_pid_to_str (ptid)) 1180 return target_beneath->to_pid_to_str (ptid); 1181 1182 return normal_pid_to_str (ptid); 1183} 1184 1185/* Get the address of the thread local variable in OBJFILE which is 1186 stored at OFFSET within the thread local storage for thread PTID. */ 1187 1188static CORE_ADDR 1189thread_db_get_thread_local_address (ptid_t ptid, struct objfile *objfile, 1190 CORE_ADDR offset) 1191{ 1192 if (is_thread (ptid)) 1193 { 1194 int objfile_is_library = (objfile->flags & OBJF_SHARED); 1195 td_err_e err; 1196 void *address; 1197 CORE_ADDR lm; 1198 struct thread_info *thread_info; 1199 1200 /* glibc doesn't provide the needed interface. */ 1201 if (!td_thr_tls_get_addr_p) 1202 error ("Cannot find thread-local variables in this thread library."); 1203 1204 /* Get the address of the link map for this objfile. */ 1205 lm = svr4_fetch_objfile_link_map (objfile); 1206 1207 /* Whoops, we couldn't find one. Bail out. */ 1208 if (!lm) 1209 { 1210 if (objfile_is_library) 1211 error ("Cannot find shared library `%s' link_map in dynamic" 1212 " linker's module list", objfile->name); 1213 else 1214 error ("Cannot find executable file `%s' link_map in dynamic" 1215 " linker's module list", objfile->name); 1216 } 1217 1218 /* Get info about the thread. */ 1219 thread_info = find_thread_pid (ptid); 1220 thread_db_map_id2thr (thread_info, 1); 1221 1222 /* Finally, get the address of the variable. */ 1223 err = td_thr_tls_get_addr_p (&thread_info->private->th, (void *) lm, 1224 offset, &address); 1225 1226#ifdef THREAD_DB_HAS_TD_NOTALLOC 1227 /* The memory hasn't been allocated, yet. */ 1228 if (err == TD_NOTALLOC) 1229 { 1230 /* Now, if libthread_db provided the initialization image's 1231 address, we *could* try to build a non-lvalue value from 1232 the initialization image. */ 1233 if (objfile_is_library) 1234 error ("The inferior has not yet allocated storage for" 1235 " thread-local variables in\n" 1236 "the shared library `%s'\n" 1237 "for the thread %ld", 1238 objfile->name, (long) GET_THREAD (ptid)); 1239 else 1240 error ("The inferior has not yet allocated storage for" 1241 " thread-local variables in\n" 1242 "the executable `%s'\n" 1243 "for the thread %ld", 1244 objfile->name, (long) GET_THREAD (ptid)); 1245 } 1246#endif 1247 1248 /* Something else went wrong. */ 1249 if (err != TD_OK) 1250 { 1251 if (objfile_is_library) 1252 error ("Cannot find thread-local storage for thread %ld, " 1253 "shared library %s:\n%s", 1254 (long) GET_THREAD (ptid), 1255 objfile->name, thread_db_err_str (err)); 1256 else 1257 error ("Cannot find thread-local storage for thread %ld, " 1258 "executable file %s:\n%s", 1259 (long) GET_THREAD (ptid), 1260 objfile->name, thread_db_err_str (err)); 1261 } 1262 1263 /* Cast assuming host == target. Joy. */ 1264 return (CORE_ADDR) address; 1265 } 1266 1267 if (target_beneath->to_get_thread_local_address) 1268 return target_beneath->to_get_thread_local_address (ptid, objfile, 1269 offset); 1270 1271 error ("Cannot find thread-local values on this target."); 1272} 1273 1274static void 1275init_thread_db_ops (void) 1276{ 1277 thread_db_ops.to_shortname = "multi-thread"; 1278 thread_db_ops.to_longname = "multi-threaded child process."; 1279 thread_db_ops.to_doc = "Threads and pthreads support."; 1280 thread_db_ops.to_attach = thread_db_attach; 1281 thread_db_ops.to_detach = thread_db_detach; 1282 thread_db_ops.to_resume = thread_db_resume; 1283 thread_db_ops.to_wait = thread_db_wait; 1284 thread_db_ops.to_fetch_registers = thread_db_fetch_registers; 1285 thread_db_ops.to_store_registers = thread_db_store_registers; 1286 thread_db_ops.to_xfer_memory = thread_db_xfer_memory; 1287 thread_db_ops.to_kill = thread_db_kill; 1288 thread_db_ops.to_create_inferior = thread_db_create_inferior; 1289 thread_db_ops.to_post_startup_inferior = thread_db_post_startup_inferior; 1290 thread_db_ops.to_mourn_inferior = thread_db_mourn_inferior; 1291 thread_db_ops.to_thread_alive = thread_db_thread_alive; 1292 thread_db_ops.to_find_new_threads = thread_db_find_new_threads; 1293 thread_db_ops.to_pid_to_str = thread_db_pid_to_str; 1294 thread_db_ops.to_stratum = thread_stratum; 1295 thread_db_ops.to_has_thread_control = tc_schedlock; 1296 thread_db_ops.to_get_thread_local_address 1297 = thread_db_get_thread_local_address; 1298 thread_db_ops.to_magic = OPS_MAGIC; 1299} 1300 1301void 1302_initialize_thread_db (void) 1303{ 1304 /* Only initialize the module if we can load libthread_db. */ 1305 if (thread_db_load ()) 1306 { 1307 init_thread_db_ops (); 1308 add_target (&thread_db_ops); 1309 1310 /* Add ourselves to objfile event chain. */ 1311 target_new_objfile_chain = target_new_objfile_hook; 1312 target_new_objfile_hook = thread_db_new_objfile; 1313 } 1314} 1315