gdb/thread-db.c

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