gdb/thread-db.c

   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.  */
  51 static struct target_ops thread_db_ops;
  52
  53 /* The target vector that we call for things this module can't handle.  */
  54 static struct target_ops *target_beneath;
  55
  56 /* Pointer to the next function on the objfile event chain.  */
  57 static void (*target_new_objfile_chain) (struct objfile * objfile);
  58
  59 /* Non-zero if we're using this module's target vector.  */
  60 static int using_thread_db;
  61
  62 /* Non-zero if we have to keep this module's target vector active
  63    across re-runs.  */
  64 static int keep_thread_db;
  65
  66 /* Non-zero if we have determined the signals used by the threads
  67    library.  */
  68 static int thread_signals;
  69 static sigset_t thread_stop_set;
  70 static sigset_t thread_print_set;
  71
  72 /* Structure that identifies the child process for the
  73    <proc_service.h> interface.  */
  74 static struct ps_prochandle proc_handle;
  75
  76 /* Connection to the libthread_db library.  */
  77 static td_thragent_t *thread_agent;
  78
  79 /* Pointers to the libthread_db functions.  */
  80
  81 static td_err_e (*td_init_p) (void);
  82
  83 static td_err_e (*td_ta_new_p) (struct ps_prochandle * ps,
  84                                 td_thragent_t **ta);
  85 static td_err_e (*td_ta_map_id2thr_p) (const td_thragent_t *ta, thread_t pt,
  86                                        td_thrhandle_t *__th);
  87 static td_err_e (*td_ta_map_lwp2thr_p) (const td_thragent_t *ta,
  88                                         lwpid_t lwpid, td_thrhandle_t *th);
  89 static 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);
  94 static td_err_e (*td_ta_event_addr_p) (const td_thragent_t *ta,
  95                                        td_event_e event, td_notify_t *ptr);
  96 static td_err_e (*td_ta_set_event_p) (const td_thragent_t *ta,
  97                                       td_thr_events_t *event);
  98 static td_err_e (*td_ta_event_getmsg_p) (const td_thragent_t *ta,
  99                                          td_event_msg_t *msg);
 100
 101 static td_err_e (*td_thr_validate_p) (const td_thrhandle_t *th);
 102 static td_err_e (*td_thr_get_info_p) (const td_thrhandle_t *th,
 103                                       td_thrinfo_t *infop);
 104 static td_err_e (*td_thr_getfpregs_p) (const td_thrhandle_t *th,
 105                                        gdb_prfpregset_t *regset);
 106 static td_err_e (*td_thr_getgregs_p) (const td_thrhandle_t *th,
 107                                       prgregset_t gregs);
 108 static td_err_e (*td_thr_setfpregs_p) (const td_thrhandle_t *th,
 109                                        const gdb_prfpregset_t *fpregs);
 110 static td_err_e (*td_thr_setgregs_p) (const td_thrhandle_t *th,
 111                                       prgregset_t gregs);
 112 static td_err_e (*td_thr_event_enable_p) (const td_thrhandle_t *th,
 113                                           int event);
 114
 115 static 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.  */
 124 static CORE_ADDR td_create_bp_addr;
 125
 126 /* Location of the thread death event breakpoint.  */
 127 static CORE_ADDR td_death_bp_addr;
 128
 129 /* Prototypes for local functions.  */
 130 static void thread_db_find_new_threads (void);
 131 static void attach_thread (ptid_t ptid, const td_thrhandle_t *th_p,
 132                            const td_thrinfo_t *ti_p, int verbose);
 133 \f
 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 \f
 147
 148 /* Use "struct private_thread_info" to cache thread state.  This is
 149    a substantial optimization.  */
 150
 151 struct 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 \f
 161
 162 static char *
 163 thread_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
 217 static char *
 218 thread_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 \f
 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
 249 static int
 250 thread_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
 287 static void
 288 thread_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
 308 static td_thrinfo_t *
 309 thread_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 \f
 329 /* Convert between user-level thread ids and LWP ids.  */
 330
 331 static ptid_t
 332 thread_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
 356 static ptid_t
 357 lwp_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 \f
 371
 372 void
 373 thread_db_init (struct target_ops *target)
 374 {
 375   target_beneath = target;
 376 }
 377
 378 static void *
 379 verbose_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
 387 static int
 388 thread_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
 468 static td_err_e
 469 enable_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, &notify);
 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                                               &current_target);
 483   create_thread_event_breakpoint ((*bp));
 484
 485   return TD_OK;
 486 }
 487
 488 static void
 489 enable_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
 543 static void
 544 disable_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
 559 static void
 560 check_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
 587 static void
 588 disable_thread_signals (void)
 589 {
 590 #ifdef GET_THREAD_SIGNALS
 591   if (thread_signals)
 592     {
 593       int i;
 594
 595       for (i = 1; i < NSIG; i++)
 596         {
 597           if (sigismember (&thread_stop_set, i))
 598             signal_stop_update (target_signal_from_host (i), 1);
 599           if (sigismember (&thread_print_set, i))
 600             signal_print_update (target_signal_from_host (i), 1);
 601         }
 602
 603       thread_signals = 0;
 604     }
 605 #endif
 606 }
 607
 608 static void
 609 thread_db_new_objfile (struct objfile *objfile)
 610 {
 611   td_err_e err;
 612
 613   /* First time through, report that libthread_db was successfuly
 614      loaded.  Can't print this in in thread_db_load as, at that stage,
 615      the interpreter and it's console haven't started.  The real
 616      problem here is that libthread_db is loaded too early - it should
 617      only be loaded when there is a program to debug.  */
 618   {
 619     static int dejavu;
 620     if (!dejavu)
 621       {
 622         Dl_info info;
 623         const char *library = NULL;
 624         /* Try dladdr.  */
 625         if (dladdr ((*td_ta_new_p), &info) != 0)
 626           library = info.dli_fname;
 627         /* Try dlinfo?  */
 628         if (library == NULL)
 629           /* Paranoid - don't let a NULL path slip through.  */
 630           library = LIBTHREAD_DB_SO;
 631         printf_unfiltered ("Using host libthread_db library \"%s\".\n",
 632                            library);
 633         dejavu = 1;
 634       }
 635   }
 636
 637   /* Don't attempt to use thread_db on targets which can not run
 638      (core files).  */
 639   if (objfile == NULL || !target_has_execution)
 640     {
 641       /* All symbols have been discarded.  If the thread_db target is
 642          active, deactivate it now.  */
 643       if (using_thread_db)
 644         {
 645           gdb_assert (proc_handle.pid == 0);
 646           unpush_target (&thread_db_ops);
 647           using_thread_db = 0;
 648         }
 649
 650       keep_thread_db = 0;
 651
 652       goto quit;
 653     }
 654
 655   if (using_thread_db)
 656     /* Nothing to do.  The thread library was already detected and the
 657        target vector was already activated.  */
 658     goto quit;
 659
 660   /* Initialize the structure that identifies the child process.  Note
 661      that at this point there is no guarantee that we actually have a
 662      child process.  */
 663   proc_handle.pid = GET_PID (inferior_ptid);
 664
 665   /* Now attempt to open a connection to the thread library.  */
 666   err = td_ta_new_p (&proc_handle, &thread_agent);
 667   switch (err)
 668     {
 669     case TD_NOLIBTHREAD:
 670       /* No thread library was detected.  */
 671       break;
 672
 673     case TD_OK:
 674       printf_unfiltered ("[Thread debugging using libthread_db enabled]\n");
 675
 676       /* The thread library was detected.  Activate the thread_db target.  */
 677       push_target (&thread_db_ops);
 678       using_thread_db = 1;
 679
 680       /* If the thread library was detected in the main symbol file
 681          itself, we assume that the program was statically linked
 682          against the thread library and well have to keep this
 683          module's target vector activated until forever...  Well, at
 684          least until all symbols have been discarded anyway (see
 685          above).  */
 686       if (objfile == symfile_objfile)
 687         {
 688           gdb_assert (proc_handle.pid == 0);
 689           keep_thread_db = 1;
 690         }
 691
 692       /* We can only poke around if there actually is a child process.
 693          If there is no child process alive, postpone the steps below
 694          until one has been created.  */
 695       if (proc_handle.pid != 0)
 696         {
 697           enable_thread_event_reporting ();
 698           thread_db_find_new_threads ();
 699         }
 700       break;
 701
 702     default:
 703       warning ("Cannot initialize thread debugging library: %s",
 704                thread_db_err_str (err));
 705       break;
 706     }
 707
 708 quit:
 709   if (target_new_objfile_chain)
 710     target_new_objfile_chain (objfile);
 711 }
 712
 713 static void
 714 attach_thread (ptid_t ptid, const td_thrhandle_t *th_p,
 715                const td_thrinfo_t *ti_p, int verbose)
 716 {
 717   struct thread_info *tp;
 718   td_err_e err;
 719
 720   check_thread_signals ();
 721
 722   /* Add the thread to GDB's thread list.  */
 723   tp = add_thread (ptid);
 724   tp->private = xmalloc (sizeof (struct private_thread_info));
 725   memset (tp->private, 0, sizeof (struct private_thread_info));
 726
 727   if (verbose)
 728     printf_unfiltered ("[New %s]\n", target_pid_to_str (ptid));
 729
 730   if (ti_p->ti_state == TD_THR_UNKNOWN || ti_p->ti_state == TD_THR_ZOMBIE)
 731     return;                     /* A zombie thread -- do not attach.  */
 732
 733   /* Under GNU/Linux, we have to attach to each and every thread.  */
 734 #ifdef ATTACH_LWP
 735   ATTACH_LWP (BUILD_LWP (ti_p->ti_lid, GET_PID (ptid)), 0);
 736 #endif
 737
 738   /* Enable thread event reporting for this thread.  */
 739   err = td_thr_event_enable_p (th_p, 1);
 740   if (err != TD_OK)
 741     error ("Cannot enable thread event reporting for %s: %s",
 742            target_pid_to_str (ptid), thread_db_err_str (err));
 743 }
 744
 745 static void
 746 thread_db_attach (char *args, int from_tty)
 747 {
 748   target_beneath->to_attach (args, from_tty);
 749
 750   /* Destroy thread info; it's no longer valid.  */
 751   init_thread_list ();
 752
 753   /* The child process is now the actual multi-threaded
 754      program.  Snatch its process ID...  */
 755   proc_handle.pid = GET_PID (inferior_ptid);
 756
 757   /* ...and perform the remaining initialization steps.  */
 758   enable_thread_event_reporting ();
 759   thread_db_find_new_threads ();
 760 }
 761
 762 static void
 763 detach_thread (ptid_t ptid, int verbose)
 764 {
 765   if (verbose)
 766     printf_unfiltered ("[%s exited]\n", target_pid_to_str (ptid));
 767 }
 768
 769 static void
 770 thread_db_detach (char *args, int from_tty)
 771 {
 772   disable_thread_event_reporting ();
 773
 774   /* There's no need to save & restore inferior_ptid here, since the
 775      inferior is supposed to be survive this function call.  */
 776   inferior_ptid = lwp_from_thread (inferior_ptid);
 777
 778   /* Forget about the child's process ID.  We shouldn't need it
 779      anymore.  */
 780   proc_handle.pid = 0;
 781
 782   target_beneath->to_detach (args, from_tty);
 783 }
 784
 785 static int
 786 clear_lwpid_callback (struct thread_info *thread, void *dummy)
 787 {
 788   /* If we know that our thread implementation is 1-to-1, we could save
 789      a certain amount of information; it's not clear how much, so we
 790      are always conservative.  */
 791
 792   thread->private->th_valid = 0;
 793   thread->private->ti_valid = 0;
 794
 795   return 0;
 796 }
 797
 798 static void
 799 thread_db_resume (ptid_t ptid, int step, enum target_signal signo)
 800 {
 801   struct cleanup *old_chain = save_inferior_ptid ();
 802
 803   if (GET_PID (ptid) == -1)
 804     inferior_ptid = lwp_from_thread (inferior_ptid);
 805   else if (is_thread (ptid))
 806     ptid = lwp_from_thread (ptid);
 807
 808   /* Clear cached data which may not be valid after the resume.  */
 809   iterate_over_threads (clear_lwpid_callback, NULL);
 810
 811   target_beneath->to_resume (ptid, step, signo);
 812
 813   do_cleanups (old_chain);
 814 }
 815
 816 /* Check if PID is currently stopped at the location of a thread event
 817    breakpoint location.  If it is, read the event message and act upon
 818    the event.  */
 819
 820 static void
 821 check_event (ptid_t ptid)
 822 {
 823   td_event_msg_t msg;
 824   td_thrinfo_t ti;
 825   td_err_e err;
 826   CORE_ADDR stop_pc;
 827   int loop = 0;
 828
 829   /* Bail out early if we're not at a thread event breakpoint.  */
 830   stop_pc = read_pc_pid (ptid) - DECR_PC_AFTER_BREAK;
 831   if (stop_pc != td_create_bp_addr && stop_pc != td_death_bp_addr)
 832     return;
 833
 834   /* If we are at a create breakpoint, we do not know what new lwp
 835      was created and cannot specifically locate the event message for it.
 836      We have to call td_ta_event_getmsg() to get
 837      the latest message.  Since we have no way of correlating whether
 838      the event message we get back corresponds to our breakpoint, we must
 839      loop and read all event messages, processing them appropriately.
 840      This guarantees we will process the correct message before continuing
 841      from the breakpoint.
 842
 843      Currently, death events are not enabled.  If they are enabled,
 844      the death event can use the td_thr_event_getmsg() interface to
 845      get the message specifically for that lwp and avoid looping
 846      below.  */
 847
 848   loop = 1;
 849
 850   do
 851     {
 852       err = td_ta_event_getmsg_p (thread_agent, &msg);
 853       if (err != TD_OK)
 854         {
 855           if (err == TD_NOMSG)
 856             return;
 857
 858           error ("Cannot get thread event message: %s",
 859                  thread_db_err_str (err));
 860         }
 861
 862       err = td_thr_get_info_p (msg.th_p, &ti);
 863       if (err != TD_OK)
 864         error ("Cannot get thread info: %s", thread_db_err_str (err));
 865
 866       ptid = BUILD_THREAD (ti.ti_tid, GET_PID (ptid));
 867
 868       switch (msg.event)
 869         {
 870         case TD_CREATE:
 871
 872           /* We may already know about this thread, for instance when the
 873              user has issued the `info threads' command before the SIGTRAP
 874              for hitting the thread creation breakpoint was reported.  */
 875           if (!in_thread_list (ptid))
 876             attach_thread (ptid, msg.th_p, &ti, 1);
 877
 878           break;
 879
 880         case TD_DEATH:
 881
 882           if (!in_thread_list (ptid))
 883             error ("Spurious thread death event.");
 884
 885           detach_thread (ptid, 1);
 886
 887           break;
 888
 889         default:
 890           error ("Spurious thread event.");
 891         }
 892     }
 893   while (loop);
 894 }
 895
 896 static ptid_t
 897 thread_db_wait (ptid_t ptid, struct target_waitstatus *ourstatus)
 898 {
 899   extern ptid_t trap_ptid;
 900
 901   if (GET_PID (ptid) != -1 && is_thread (ptid))
 902     ptid = lwp_from_thread (ptid);
 903
 904   ptid = target_beneath->to_wait (ptid, ourstatus);
 905
 906   if (proc_handle.pid == 0)
 907     /* The current child process isn't the actual multi-threaded
 908        program yet, so don't try to do any special thread-specific
 909        post-processing and bail out early.  */
 910     return ptid;
 911
 912   if (ourstatus->kind == TARGET_WAITKIND_EXITED)
 913     return pid_to_ptid (-1);
 914
 915   if (ourstatus->kind == TARGET_WAITKIND_STOPPED
 916       && ourstatus->value.sig == TARGET_SIGNAL_TRAP)
 917     /* Check for a thread event.  */
 918     check_event (ptid);
 919
 920   if (!ptid_equal (trap_ptid, null_ptid))
 921     trap_ptid = thread_from_lwp (trap_ptid);
 922
 923   return thread_from_lwp (ptid);
 924 }
 925
 926 static int
 927 thread_db_xfer_memory (CORE_ADDR memaddr, char *myaddr, int len, int write,
 928                        struct mem_attrib *attrib, struct target_ops *target)
 929 {
 930   struct cleanup *old_chain = save_inferior_ptid ();
 931   int xfer;
 932
 933   if (is_thread (inferior_ptid))
 934     {
 935       /* FIXME: This seems to be necessary to make sure breakpoints
 936          are removed.  */
 937       if (!target_thread_alive (inferior_ptid))
 938         inferior_ptid = pid_to_ptid (GET_PID (inferior_ptid));
 939       else
 940         inferior_ptid = lwp_from_thread (inferior_ptid);
 941     }
 942
 943   xfer =
 944     target_beneath->to_xfer_memory (memaddr, myaddr, len, write, attrib,
 945                                     target);
 946
 947   do_cleanups (old_chain);
 948   return xfer;
 949 }
 950
 951 static void
 952 thread_db_fetch_registers (int regno)
 953 {
 954   struct thread_info *thread_info;
 955   prgregset_t gregset;
 956   gdb_prfpregset_t fpregset;
 957   td_err_e err;
 958
 959   if (!is_thread (inferior_ptid))
 960     {
 961       /* Pass the request to the target beneath us.  */
 962       target_beneath->to_fetch_registers (regno);
 963       return;
 964     }
 965
 966   thread_info = find_thread_pid (inferior_ptid);
 967   thread_db_map_id2thr (thread_info, 1);
 968
 969   err = td_thr_getgregs_p (&thread_info->private->th, gregset);
 970   if (err != TD_OK)
 971     error ("Cannot fetch general-purpose registers for thread %ld: %s",
 972            (long) GET_THREAD (inferior_ptid), thread_db_err_str (err));
 973
 974   err = td_thr_getfpregs_p (&thread_info->private->th, &fpregset);
 975   if (err != TD_OK)
 976     error ("Cannot get floating-point registers for thread %ld: %s",
 977            (long) GET_THREAD (inferior_ptid), thread_db_err_str (err));
 978
 979   /* Note that we must call supply_gregset after calling the thread_db
 980      routines because the thread_db routines call ps_lgetgregs and
 981      friends which clobber GDB's register cache.  */
 982   supply_gregset ((gdb_gregset_t *) gregset);
 983   supply_fpregset (&fpregset);
 984 }
 985
 986 static void
 987 thread_db_store_registers (int regno)
 988 {
 989   prgregset_t gregset;
 990   gdb_prfpregset_t fpregset;
 991   td_err_e err;
 992   struct thread_info *thread_info;
 993
 994   if (!is_thread (inferior_ptid))
 995     {
 996       /* Pass the request to the target beneath us.  */
 997       target_beneath->to_store_registers (regno);
 998       return;
 999     }
1000
1001   thread_info = find_thread_pid (inferior_ptid);
1002   thread_db_map_id2thr (thread_info, 1);
1003
1004   if (regno != -1)
1005     {
1006       char raw[MAX_REGISTER_SIZE];
1007
1008       deprecated_read_register_gen (regno, raw);
1009       thread_db_fetch_registers (-1);
1010       supply_register (regno, raw);
1011     }
1012
1013   fill_gregset ((gdb_gregset_t *) gregset, -1);
1014   fill_fpregset (&fpregset, -1);
1015
1016   err = td_thr_setgregs_p (&thread_info->private->th, gregset);
1017   if (err != TD_OK)
1018     error ("Cannot store general-purpose registers for thread %ld: %s",
1019            (long) GET_THREAD (inferior_ptid), thread_db_err_str (err));
1020   err = td_thr_setfpregs_p (&thread_info->private->th, &fpregset);
1021   if (err != TD_OK)
1022     error ("Cannot store floating-point registers  for thread %ld: %s",
1023            (long) GET_THREAD (inferior_ptid), thread_db_err_str (err));
1024 }
1025
1026 static void
1027 thread_db_kill (void)
1028 {
1029   /* There's no need to save & restore inferior_ptid here, since the
1030      inferior isn't supposed to survive this function call.  */
1031   inferior_ptid = lwp_from_thread (inferior_ptid);
1032   target_beneath->to_kill ();
1033 }
1034
1035 static void
1036 thread_db_create_inferior (char *exec_file, char *allargs, char **env)
1037 {
1038   if (!keep_thread_db)
1039     {
1040       unpush_target (&thread_db_ops);
1041       using_thread_db = 0;
1042     }
1043
1044   target_beneath->to_create_inferior (exec_file, allargs, env);
1045 }
1046
1047 static void
1048 thread_db_post_startup_inferior (ptid_t ptid)
1049 {
1050   if (proc_handle.pid == 0)
1051     {
1052       /* The child process is now the actual multi-threaded
1053          program.  Snatch its process ID...  */
1054       proc_handle.pid = GET_PID (ptid);
1055
1056       /* ...and perform the remaining initialization steps.  */
1057       enable_thread_event_reporting ();
1058       thread_db_find_new_threads ();
1059     }
1060 }
1061
1062 static void
1063 thread_db_mourn_inferior (void)
1064 {
1065   remove_thread_event_breakpoints ();
1066
1067   /* Forget about the child's process ID.  We shouldn't need it
1068      anymore.  */
1069   proc_handle.pid = 0;
1070
1071   target_beneath->to_mourn_inferior ();
1072
1073   /* Detach thread_db target ops if not dealing with a statically
1074      linked threaded program.  This allows a corefile to be debugged
1075      after finishing debugging of a threaded program.  At present,
1076      debugging a statically-linked threaded program is broken, but
1077      the check is added below in the event that it is fixed in the
1078      future.  */
1079   if (!keep_thread_db)
1080     {
1081       unpush_target (&thread_db_ops);
1082       using_thread_db = 0;
1083     }
1084 }
1085
1086 static int
1087 thread_db_thread_alive (ptid_t ptid)
1088 {
1089   td_thrhandle_t th;
1090   td_err_e err;
1091
1092   if (is_thread (ptid))
1093     {
1094       struct thread_info *thread_info;
1095       thread_info = find_thread_pid (ptid);
1096
1097       thread_db_map_id2thr (thread_info, 0);
1098       if (!thread_info->private->th_valid)
1099         return 0;
1100
1101       err = td_thr_validate_p (&thread_info->private->th);
1102       if (err != TD_OK)
1103         return 0;
1104
1105       if (!thread_info->private->ti_valid)
1106         {
1107           err =
1108             td_thr_get_info_p (&thread_info->private->th,
1109                                &thread_info->private->ti);
1110           if (err != TD_OK)
1111             return 0;
1112           thread_info->private->ti_valid = 1;
1113         }
1114
1115       if (thread_info->private->ti.ti_state == TD_THR_UNKNOWN
1116           || thread_info->private->ti.ti_state == TD_THR_ZOMBIE)
1117         return 0;               /* A zombie thread.  */
1118
1119       return 1;
1120     }
1121
1122   if (target_beneath->to_thread_alive)
1123     return target_beneath->to_thread_alive (ptid);
1124
1125   return 0;
1126 }
1127
1128 static int
1129 find_new_threads_callback (const td_thrhandle_t *th_p, void *data)
1130 {
1131   td_thrinfo_t ti;
1132   td_err_e err;
1133   ptid_t ptid;
1134
1135   err = td_thr_get_info_p (th_p, &ti);
1136   if (err != TD_OK)
1137     error ("find_new_threads_callback: cannot get thread info: %s",
1138            thread_db_err_str (err));
1139
1140   if (ti.ti_state == TD_THR_UNKNOWN || ti.ti_state == TD_THR_ZOMBIE)
1141     return 0;                   /* A zombie -- ignore.  */
1142
1143   ptid = BUILD_THREAD (ti.ti_tid, GET_PID (inferior_ptid));
1144
1145   if (!in_thread_list (ptid))
1146     attach_thread (ptid, th_p, &ti, 1);
1147
1148   return 0;
1149 }
1150
1151 static void
1152 thread_db_find_new_threads (void)
1153 {
1154   td_err_e err;
1155
1156   /* Iterate over all user-space threads to discover new threads.  */
1157   err = td_ta_thr_iter_p (thread_agent, find_new_threads_callback, NULL,
1158                           TD_THR_ANY_STATE, TD_THR_LOWEST_PRIORITY,
1159                           TD_SIGNO_MASK, TD_THR_ANY_USER_FLAGS);
1160   if (err != TD_OK)
1161     error ("Cannot find new threads: %s", thread_db_err_str (err));
1162 }
1163
1164 static char *
1165 thread_db_pid_to_str (ptid_t ptid)
1166 {
1167   if (is_thread (ptid))
1168     {
1169       static char buf[64];
1170       td_thrinfo_t *ti_p;
1171       td_err_e err;
1172       struct thread_info *thread_info;
1173
1174       thread_info = find_thread_pid (ptid);
1175       thread_db_map_id2thr (thread_info, 0);
1176       if (!thread_info->private->th_valid)
1177         {
1178           snprintf (buf, sizeof (buf), "Thread %ld (Missing)",
1179                     GET_THREAD (ptid));
1180           return buf;
1181         }
1182
1183       ti_p = thread_db_get_info (thread_info);
1184
1185       if (ti_p->ti_state == TD_THR_ACTIVE && ti_p->ti_lid != 0)
1186         {
1187           snprintf (buf, sizeof (buf), "Thread %ld (LWP %d)",
1188                     (long) ti_p->ti_tid, ti_p->ti_lid);
1189         }
1190       else
1191         {
1192           snprintf (buf, sizeof (buf), "Thread %ld (%s)",
1193                     (long) ti_p->ti_tid,
1194                     thread_db_state_str (ti_p->ti_state));
1195         }
1196
1197       return buf;
1198     }
1199
1200   if (target_beneath->to_pid_to_str (ptid))
1201     return target_beneath->to_pid_to_str (ptid);
1202
1203   return normal_pid_to_str (ptid);
1204 }
1205
1206 /* Get the address of the thread local variable in OBJFILE which is
1207    stored at OFFSET within the thread local storage for thread PTID.  */
1208
1209 static CORE_ADDR
1210 thread_db_get_thread_local_address (ptid_t ptid, struct objfile *objfile,
1211                                     CORE_ADDR offset)
1212 {
1213   if (is_thread (ptid))
1214     {
1215       int objfile_is_library = (objfile->flags & OBJF_SHARED);
1216       td_err_e err;
1217       void *address;
1218       CORE_ADDR lm;
1219       struct thread_info *thread_info;
1220
1221       /* glibc doesn't provide the needed interface.  */
1222       if (!td_thr_tls_get_addr_p)
1223         error ("Cannot find thread-local variables in this thread library.");
1224
1225       /* Get the address of the link map for this objfile.  */
1226       lm = svr4_fetch_objfile_link_map (objfile);
1227
1228       /* Whoops, we couldn't find one. Bail out.  */
1229       if (!lm)
1230         {
1231           if (objfile_is_library)
1232             error ("Cannot find shared library `%s' link_map in dynamic"
1233                    " linker's module list", objfile->name);
1234           else
1235             error ("Cannot find executable file `%s' link_map in dynamic"
1236                    " linker's module list", objfile->name);
1237         }
1238
1239       /* Get info about the thread.  */
1240       thread_info = find_thread_pid (ptid);
1241       thread_db_map_id2thr (thread_info, 1);
1242
1243       /* Finally, get the address of the variable.  */
1244       err = td_thr_tls_get_addr_p (&thread_info->private->th, (void *) lm,
1245                                    offset, &address);
1246
1247 #ifdef THREAD_DB_HAS_TD_NOTALLOC
1248       /* The memory hasn't been allocated, yet.  */
1249       if (err == TD_NOTALLOC)
1250         {
1251           /* Now, if libthread_db provided the initialization image's
1252              address, we *could* try to build a non-lvalue value from
1253              the initialization image.  */
1254           if (objfile_is_library)
1255             error ("The inferior has not yet allocated storage for"
1256                    " thread-local variables in\n"
1257                    "the shared library `%s'\n"
1258                    "for the thread %ld",
1259                    objfile->name, (long) GET_THREAD (ptid));
1260           else
1261             error ("The inferior has not yet allocated storage for"
1262                    " thread-local variables in\n"
1263                    "the executable `%s'\n"
1264                    "for the thread %ld",
1265                    objfile->name, (long) GET_THREAD (ptid));
1266         }
1267 #endif
1268
1269       /* Something else went wrong.  */
1270       if (err != TD_OK)
1271         {
1272           if (objfile_is_library)
1273             error ("Cannot find thread-local storage for thread %ld, "
1274                    "shared library %s:\n%s",
1275                    (long) GET_THREAD (ptid),
1276                    objfile->name, thread_db_err_str (err));
1277           else
1278             error ("Cannot find thread-local storage for thread %ld, "
1279                    "executable file %s:\n%s",
1280                    (long) GET_THREAD (ptid),
1281                    objfile->name, thread_db_err_str (err));
1282         }
1283
1284       /* Cast assuming host == target.  Joy.  */
1285       return (CORE_ADDR) address;
1286     }
1287
1288   if (target_beneath->to_get_thread_local_address)
1289     return target_beneath->to_get_thread_local_address (ptid, objfile,
1290                                                         offset);
1291
1292   error ("Cannot find thread-local values on this target.");
1293 }
1294
1295 static void
1296 init_thread_db_ops (void)
1297 {
1298   thread_db_ops.to_shortname = "multi-thread";
1299   thread_db_ops.to_longname = "multi-threaded child process.";
1300   thread_db_ops.to_doc = "Threads and pthreads support.";
1301   thread_db_ops.to_attach = thread_db_attach;
1302   thread_db_ops.to_detach = thread_db_detach;
1303   thread_db_ops.to_resume = thread_db_resume;
1304   thread_db_ops.to_wait = thread_db_wait;
1305   thread_db_ops.to_fetch_registers = thread_db_fetch_registers;
1306   thread_db_ops.to_store_registers = thread_db_store_registers;
1307   thread_db_ops.to_xfer_memory = thread_db_xfer_memory;
1308   thread_db_ops.to_kill = thread_db_kill;
1309   thread_db_ops.to_create_inferior = thread_db_create_inferior;
1310   thread_db_ops.to_post_startup_inferior = thread_db_post_startup_inferior;
1311   thread_db_ops.to_mourn_inferior = thread_db_mourn_inferior;
1312   thread_db_ops.to_thread_alive = thread_db_thread_alive;
1313   thread_db_ops.to_find_new_threads = thread_db_find_new_threads;
1314   thread_db_ops.to_pid_to_str = thread_db_pid_to_str;
1315   thread_db_ops.to_stratum = thread_stratum;
1316   thread_db_ops.to_has_thread_control = tc_schedlock;
1317   thread_db_ops.to_get_thread_local_address
1318     = thread_db_get_thread_local_address;
1319   thread_db_ops.to_magic = OPS_MAGIC;
1320 }
1321
1322 void
1323 _initialize_thread_db (void)
1324 {
1325   /* Only initialize the module if we can load libthread_db.  */
1326   if (thread_db_load ())
1327     {
1328       init_thread_db_ops ();
1329       add_target (&thread_db_ops);
1330
1331       /* Add ourselves to objfile event chain.  */
1332       target_new_objfile_chain = target_new_objfile_hook;
1333       target_new_objfile_hook = thread_db_new_objfile;
1334     }
1335 }