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
  36 #ifndef LIBTHREAD_DB_SO
  37 #define LIBTHREAD_DB_SO "libthread_db.so.1"
  38 #endif
  39
  40 /* If we're running on Linux, we must explicitly attach to any new threads.  */
  41
  42 /* FIXME: There is certainly some room for improvements:
  43    - Cache LWP ids.
  44    - Bypass libthread_db when fetching or storing registers for
  45    threads bound to a LWP.  */
  46
  47 /* This module's target vector.  */
  48 static struct target_ops thread_db_ops;
  49
  50 /* The target vector that we call for things this module can't handle.  */
  51 static struct target_ops *target_beneath;
  52
  53 /* Pointer to the next function on the objfile event chain.  */
  54 static void (*target_new_objfile_chain) (struct objfile *objfile);
  55
  56 /* Non-zero if we're using this module's target vector.  */
  57 static int using_thread_db;
  58
  59 /* Non-zero if we have to keep this module's target vector active
  60    across re-runs.  */
  61 static int keep_thread_db;
  62
  63 /* Non-zero if we have determined the signals used by the threads
  64    library.  */
  65 static int thread_signals;
  66 static sigset_t thread_stop_set;
  67 static sigset_t thread_print_set;
  68
  69 /* Structure that identifies the child process for the
  70    <proc_service.h> interface.  */
  71 static struct ps_prochandle proc_handle;
  72
  73 /* Connection to the libthread_db library.  */
  74 static td_thragent_t *thread_agent;
  75
  76 /* Pointers to the libthread_db functions.  */
  77
  78 static td_err_e (*td_init_p) (void);
  79
  80 static td_err_e (*td_ta_new_p) (struct ps_prochandle *ps, td_thragent_t **ta);
  81 static td_err_e (*td_ta_map_id2thr_p) (const td_thragent_t *ta, thread_t pt,
  82                                        td_thrhandle_t *__th);
  83 static td_err_e (*td_ta_map_lwp2thr_p) (const td_thragent_t *ta, lwpid_t lwpid,
  84                                         td_thrhandle_t *th);
  85 static td_err_e (*td_ta_thr_iter_p) (const td_thragent_t *ta,
  86                                      td_thr_iter_f *callback,
  87                                      void *cbdata_p, td_thr_state_e state,
  88                                      int ti_pri, sigset_t *ti_sigmask_p,
  89                                      unsigned int ti_user_flags);
  90 static td_err_e (*td_ta_event_addr_p) (const td_thragent_t *ta,
  91                                        td_event_e event, td_notify_t *ptr);
  92 static td_err_e (*td_ta_set_event_p) (const td_thragent_t *ta,
  93                                       td_thr_events_t *event);
  94 static td_err_e (*td_ta_event_getmsg_p) (const td_thragent_t *ta,
  95                                          td_event_msg_t *msg);
  96
  97 static td_err_e (*td_thr_validate_p) (const td_thrhandle_t *th);
  98 static td_err_e (*td_thr_get_info_p) (const td_thrhandle_t *th,
  99                                       td_thrinfo_t *infop);
 100 static td_err_e (*td_thr_getfpregs_p) (const td_thrhandle_t *th,
 101                                        gdb_prfpregset_t *regset);
 102 static td_err_e (*td_thr_getgregs_p) (const td_thrhandle_t *th,
 103                                       prgregset_t gregs);
 104 static td_err_e (*td_thr_setfpregs_p) (const td_thrhandle_t *th,
 105                                        const gdb_prfpregset_t *fpregs);
 106 static td_err_e (*td_thr_setgregs_p) (const td_thrhandle_t *th,
 107                                       prgregset_t gregs);
 108 static td_err_e (*td_thr_event_enable_p) (const td_thrhandle_t *th, int event);
 109
 110 /* Location of the thread creation event breakpoint.  The code at this
 111    location in the child process will be called by the pthread library
 112    whenever a new thread is created.  By setting a special breakpoint
 113    at this location, GDB can detect when a new thread is created.  We
 114    obtain this location via the td_ta_event_addr call.  */
 115 static CORE_ADDR td_create_bp_addr;
 116
 117 /* Location of the thread death event breakpoint.  */
 118 static CORE_ADDR td_death_bp_addr;
 119
 120 /* Prototypes for local functions.  */
 121 static void thread_db_find_new_threads (void);
 122 \f
 123
 124 /* Building process ids.  */
 125
 126 #define GET_PID(ptid)           ptid_get_pid (ptid)
 127 #define GET_LWP(ptid)           ptid_get_lwp (ptid)
 128 #define GET_THREAD(ptid)        ptid_get_tid (ptid)
 129
 130 #define is_lwp(ptid)            (GET_LWP (ptid) != 0)
 131 #define is_thread(ptid)         (GET_THREAD (ptid) != 0)
 132
 133 #define BUILD_LWP(lwp, pid)     ptid_build (pid, lwp, 0)
 134 #define BUILD_THREAD(tid, pid)  ptid_build (pid, 0, tid)
 135 \f
 136
 137 struct private_thread_info
 138 {
 139   /* Cached LWP id.  Must come first, see lin-lwp.c.  */
 140   lwpid_t lwpid;
 141 };
 142 \f
 143
 144 static char *
 145 thread_db_err_str (td_err_e err)
 146 {
 147   static char buf[64];
 148
 149   switch (err)
 150     {
 151     case TD_OK:
 152       return "generic 'call succeeded'";
 153     case TD_ERR:
 154       return "generic error";
 155     case TD_NOTHR:
 156       return "no thread to satisfy query";
 157     case TD_NOSV:
 158       return "no sync handle to satisfy query";
 159     case TD_NOLWP:
 160       return "no LWP to satisfy query";
 161     case TD_BADPH:
 162       return "invalid process handle";
 163     case TD_BADTH:
 164       return "invalid thread handle";
 165     case TD_BADSH:
 166       return "invalid synchronization handle";
 167     case TD_BADTA:
 168       return "invalid thread agent";
 169     case TD_BADKEY:
 170       return "invalid key";
 171     case TD_NOMSG:
 172       return "no event message for getmsg";
 173     case TD_NOFPREGS:
 174       return "FPU register set not available";
 175     case TD_NOLIBTHREAD:
 176       return "application not linked with libthread";
 177     case TD_NOEVENT:
 178       return "requested event is not supported";
 179     case TD_NOCAPAB:
 180       return "capability not available";
 181     case TD_DBERR:
 182       return "debugger service failed";
 183     case TD_NOAPLIC:
 184       return "operation not applicable to";
 185     case TD_NOTSD:
 186       return "no thread-specific data for this thread";
 187     case TD_MALLOC:
 188       return "malloc failed";
 189     case TD_PARTIALREG:
 190       return "only part of register set was written/read";
 191     case TD_NOXREGS:
 192       return "X register set not available for this thread";
 193     default:
 194       snprintf (buf, sizeof (buf), "unknown thread_db error '%d'", err);
 195       return buf;
 196     }
 197 }
 198
 199 static char *
 200 thread_db_state_str (td_thr_state_e state)
 201 {
 202   static char buf[64];
 203
 204   switch (state)
 205     {
 206     case TD_THR_STOPPED:
 207       return "stopped by debugger";
 208     case TD_THR_RUN:
 209       return "runnable";
 210     case TD_THR_ACTIVE:
 211       return "active";
 212     case TD_THR_ZOMBIE:
 213       return "zombie";
 214     case TD_THR_SLEEP:
 215       return "sleeping";
 216     case TD_THR_STOPPED_ASLEEP:
 217       return "stopped by debugger AND blocked";
 218     default:
 219       snprintf (buf, sizeof (buf), "unknown thread_db state %d", state);
 220       return buf;
 221     }
 222 }
 223 \f
 224
 225 /* Convert between user-level thread ids and LWP ids.  */
 226
 227 static ptid_t
 228 thread_from_lwp (ptid_t ptid)
 229 {
 230   td_thrinfo_t ti;
 231   td_thrhandle_t th;
 232   td_err_e err;
 233
 234   if (GET_LWP (ptid) == 0)
 235     ptid = BUILD_LWP (GET_PID (ptid), GET_PID (ptid));
 236
 237   gdb_assert (is_lwp (ptid));
 238
 239   err = td_ta_map_lwp2thr_p (thread_agent, GET_LWP (ptid), &th);
 240   if (err != TD_OK)
 241     error ("Cannot find user-level thread for LWP %d: %s",
 242            GET_LWP (ptid), thread_db_err_str (err));
 243
 244   err = td_thr_get_info_p (&th, &ti);
 245   if (err != TD_OK)
 246     error ("Cannot get thread info: %s", thread_db_err_str (err));
 247
 248   return BUILD_THREAD (ti.ti_tid, GET_PID (ptid));
 249 }
 250
 251 static ptid_t
 252 lwp_from_thread (ptid_t ptid)
 253 {
 254   td_thrinfo_t ti;
 255   td_thrhandle_t th;
 256   td_err_e err;
 257
 258   if (!is_thread (ptid))
 259     return ptid;
 260
 261   err = td_ta_map_id2thr_p (thread_agent, GET_THREAD (ptid), &th);
 262   if (err != TD_OK)
 263     error ("Cannot find thread %ld: %s",
 264            (long) GET_THREAD (ptid), thread_db_err_str (err));
 265
 266   err = td_thr_get_info_p (&th, &ti);
 267   if (err != TD_OK)
 268     error ("Cannot get thread info: %s", thread_db_err_str (err));
 269
 270   return BUILD_LWP (ti.ti_lid, GET_PID (ptid));
 271 }
 272 \f
 273
 274 void
 275 thread_db_init (struct target_ops *target)
 276 {
 277   target_beneath = target;
 278 }
 279
 280 static int
 281 thread_db_load (void)
 282 {
 283   void *handle;
 284   td_err_e err;
 285
 286   handle = dlopen (LIBTHREAD_DB_SO, RTLD_NOW);
 287   if (handle == NULL)
 288     return 0;
 289
 290   /* Initialize pointers to the dynamic library functions we will use.
 291      Essential functions first.  */
 292
 293   td_init_p = dlsym (handle, "td_init");
 294   if (td_init_p == NULL)
 295     return 0;
 296
 297   td_ta_new_p = dlsym (handle, "td_ta_new");
 298   if (td_ta_new_p == NULL)
 299     return 0;
 300
 301   td_ta_map_id2thr_p = dlsym (handle, "td_ta_map_id2thr");
 302   if (td_ta_map_id2thr_p == NULL)
 303     return 0;
 304
 305   td_ta_map_lwp2thr_p = dlsym (handle, "td_ta_map_lwp2thr");
 306   if (td_ta_map_lwp2thr_p == NULL)
 307     return 0;
 308
 309   td_ta_thr_iter_p = dlsym (handle, "td_ta_thr_iter");
 310   if (td_ta_thr_iter_p == NULL)
 311     return 0;
 312
 313   td_thr_validate_p = dlsym (handle, "td_thr_validate");
 314   if (td_thr_validate_p == NULL)
 315     return 0;
 316
 317   td_thr_get_info_p = dlsym (handle, "td_thr_get_info");
 318   if (td_thr_get_info_p == NULL)
 319     return 0;
 320
 321   td_thr_getfpregs_p = dlsym (handle, "td_thr_getfpregs");
 322   if (td_thr_getfpregs_p == NULL)
 323     return 0;
 324
 325   td_thr_getgregs_p = dlsym (handle, "td_thr_getgregs");
 326   if (td_thr_getgregs_p == NULL)
 327     return 0;
 328
 329   td_thr_setfpregs_p = dlsym (handle, "td_thr_setfpregs");
 330   if (td_thr_setfpregs_p == NULL)
 331     return 0;
 332
 333   td_thr_setgregs_p = dlsym (handle, "td_thr_setgregs");
 334   if (td_thr_setgregs_p == NULL)
 335     return 0;
 336
 337   /* Initialize the library.  */
 338   err = td_init_p ();
 339   if (err != TD_OK)
 340     {
 341       warning ("Cannot initialize libthread_db: %s", thread_db_err_str (err));
 342       return 0;
 343     }
 344
 345   /* These are not essential.  */
 346   td_ta_event_addr_p = dlsym (handle, "td_ta_event_addr");
 347   td_ta_set_event_p = dlsym (handle, "td_ta_set_event");
 348   td_ta_event_getmsg_p = dlsym (handle, "td_ta_event_getmsg");
 349   td_thr_event_enable_p = dlsym (handle, "td_thr_event_enable");
 350
 351   return 1;
 352 }
 353
 354 static void
 355 enable_thread_event_reporting (void)
 356 {
 357   td_thr_events_t events;
 358   td_notify_t notify;
 359   td_err_e err;
 360
 361   /* We cannot use the thread event reporting facility if these
 362      functions aren't available.  */
 363   if (td_ta_event_addr_p == NULL || td_ta_set_event_p == NULL
 364       || td_ta_event_getmsg_p == NULL || td_thr_event_enable_p == NULL)
 365     return;
 366
 367   /* Set the process wide mask saying which events we're interested in.  */
 368   td_event_emptyset (&events);
 369   td_event_addset (&events, TD_CREATE);
 370 #if 0
 371   /* FIXME: kettenis/2000-04-23: The event reporting facility is
 372      broken for TD_DEATH events in glibc 2.1.3, so don't enable it for
 373      now.  */
 374   td_event_addset (&events, TD_DEATH);
 375 #endif
 376
 377   err = td_ta_set_event_p (thread_agent, &events);
 378   if (err != TD_OK)
 379     {
 380       warning ("Unable to set global thread event mask: %s",
 381                thread_db_err_str (err));
 382       return;
 383     }
 384
 385   /* Delete previous thread event breakpoints, if any.  */
 386   remove_thread_event_breakpoints ();
 387
 388   /* Get address for thread creation breakpoint.  */
 389   err = td_ta_event_addr_p (thread_agent, TD_CREATE, &notify);
 390   if (err != TD_OK)
 391     {
 392       warning ("Unable to get location for thread creation breakpoint: %s",
 393                thread_db_err_str (err));
 394       return;
 395     }
 396
 397   /* Set up the breakpoint.  */
 398   td_create_bp_addr = (CORE_ADDR) notify.u.bptaddr;
 399   create_thread_event_breakpoint (td_create_bp_addr);
 400
 401   /* Get address for thread death breakpoint.  */
 402   err = td_ta_event_addr_p (thread_agent, TD_DEATH, &notify);
 403   if (err != TD_OK)
 404     {
 405       warning ("Unable to get location for thread death breakpoint: %s",
 406                thread_db_err_str (err));
 407       return;
 408     }
 409
 410   /* Set up the breakpoint.  */
 411   td_death_bp_addr = (CORE_ADDR) notify.u.bptaddr;
 412   create_thread_event_breakpoint (td_death_bp_addr);
 413 }
 414
 415 static void
 416 disable_thread_event_reporting (void)
 417 {
 418   td_thr_events_t events;
 419
 420   /* Set the process wide mask saying we aren't interested in any
 421      events anymore.  */
 422   td_event_emptyset (&events);
 423   td_ta_set_event_p (thread_agent, &events);
 424
 425   /* Delete thread event breakpoints, if any.  */
 426   remove_thread_event_breakpoints ();
 427   td_create_bp_addr = 0;
 428   td_death_bp_addr = 0;
 429 }
 430
 431 static void
 432 check_thread_signals (void)
 433 {
 434 #ifdef GET_THREAD_SIGNALS
 435   if (!thread_signals)
 436     {
 437       sigset_t mask;
 438       int i;
 439
 440       GET_THREAD_SIGNALS (&mask);
 441       sigemptyset (&thread_stop_set);
 442       sigemptyset (&thread_print_set);
 443
 444       for (i = 1; i < NSIG; i++)
 445         {
 446           if (sigismember (&mask, i))
 447             {
 448               if (signal_stop_update (target_signal_from_host (i), 0))
 449                 sigaddset (&thread_stop_set, i);
 450               if (signal_print_update (target_signal_from_host (i), 0))
 451                 sigaddset (&thread_print_set, i);
 452               thread_signals = 1;
 453             }
 454         }
 455     }
 456 #endif
 457 }
 458
 459 static void
 460 disable_thread_signals (void)
 461 {
 462 #ifdef GET_THREAD_SIGNALS
 463   if (thread_signals)
 464     {
 465       int i;
 466
 467       for (i = 1; i < NSIG; i++)
 468         {
 469           if (sigismember (&thread_stop_set, i))
 470             signal_stop_update (target_signal_from_host (i), 1);
 471           if (sigismember (&thread_print_set, i))
 472             signal_print_update (target_signal_from_host (i), 1);
 473         }
 474
 475       thread_signals = 0;
 476     }
 477 #endif
 478 }
 479
 480 static void
 481 thread_db_new_objfile (struct objfile *objfile)
 482 {
 483   td_err_e err;
 484
 485   if (objfile == NULL)
 486     {
 487       /* All symbols have been discarded.  If the thread_db target is
 488          active, deactivate it now.  */
 489       if (using_thread_db)
 490         {
 491           gdb_assert (proc_handle.pid == 0);
 492           unpush_target (&thread_db_ops);
 493           using_thread_db = 0;
 494         }
 495
 496       keep_thread_db = 0;
 497
 498       goto quit;
 499     }
 500
 501   if (using_thread_db)
 502     /* Nothing to do.  The thread library was already detected and the
 503        target vector was already activated.  */
 504     goto quit;
 505
 506   /* Initialize the structure that identifies the child process.  Note
 507      that at this point there is no guarantee that we actually have a
 508      child process.  */
 509   proc_handle.pid = GET_PID (inferior_ptid);
 510
 511   /* Now attempt to open a connection to the thread library.  */
 512   err = td_ta_new_p (&proc_handle, &thread_agent);
 513   switch (err)
 514     {
 515     case TD_NOLIBTHREAD:
 516       /* No thread library was detected.  */
 517       break;
 518
 519     case TD_OK:
 520       /* The thread library was detected.  Activate the thread_db target.  */
 521       push_target (&thread_db_ops);
 522       using_thread_db = 1;
 523
 524       /* If the thread library was detected in the main symbol file
 525          itself, we assume that the program was statically linked
 526          against the thread library and well have to keep this
 527          module's target vector activated until forever...  Well, at
 528          least until all symbols have been discarded anyway (see
 529          above).  */
 530       if (objfile == symfile_objfile)
 531         {
 532           gdb_assert (proc_handle.pid == 0);
 533           keep_thread_db = 1;
 534         }
 535
 536       /* We can only poke around if there actually is a child process.
 537          If there is no child process alive, postpone the steps below
 538          until one has been created.  */
 539       if (proc_handle.pid != 0)
 540         {
 541           enable_thread_event_reporting ();
 542           thread_db_find_new_threads ();
 543         }
 544       break;
 545
 546     default:
 547       warning ("Cannot initialize thread debugging library: %s",
 548                thread_db_err_str (err));
 549       break;
 550     }
 551
 552  quit:
 553   if (target_new_objfile_chain)
 554     target_new_objfile_chain (objfile);
 555 }
 556
 557 static void
 558 attach_thread (ptid_t ptid, const td_thrhandle_t *th_p,
 559                const td_thrinfo_t *ti_p, int verbose)
 560 {
 561   struct thread_info *tp;
 562   td_err_e err;
 563
 564   check_thread_signals ();
 565
 566   if (verbose)
 567     printf_unfiltered ("[New %s]\n", target_pid_to_str (ptid));
 568
 569   /* Add the thread to GDB's thread list.  */
 570   tp = add_thread (ptid);
 571   tp->private = xmalloc (sizeof (struct private_thread_info));
 572   tp->private->lwpid = ti_p->ti_lid;
 573
 574   if (ti_p->ti_state == TD_THR_UNKNOWN || ti_p->ti_state == TD_THR_ZOMBIE)
 575     return;                     /* A zombie thread -- do not attach.  */
 576
 577   /* Under Linux, we have to attach to each and every thread.  */
 578 #ifdef ATTACH_LWP
 579   ATTACH_LWP (BUILD_LWP (ti_p->ti_lid, GET_PID (ptid)), 0);
 580 #endif
 581
 582   /* Enable thread event reporting for this thread.  */
 583   err = td_thr_event_enable_p (th_p, 1);
 584   if (err != TD_OK)
 585     error ("Cannot enable thread event reporting for %s: %s",
 586            target_pid_to_str (ptid), thread_db_err_str (err));
 587 }
 588
 589 static void
 590 thread_db_attach (char *args, int from_tty)
 591 {
 592   target_beneath->to_attach (args, from_tty);
 593
 594   /* Destroy thread info; it's no longer valid.  */
 595   init_thread_list ();
 596
 597   /* The child process is now the actual multi-threaded
 598      program.  Snatch its process ID...  */
 599   proc_handle.pid = GET_PID (inferior_ptid);
 600
 601   /* ...and perform the remaining initialization steps.  */
 602   enable_thread_event_reporting ();
 603   thread_db_find_new_threads();
 604 }
 605
 606 static void
 607 detach_thread (ptid_t ptid, int verbose)
 608 {
 609   if (verbose)
 610     printf_unfiltered ("[%s exited]\n", target_pid_to_str (ptid));
 611 }
 612
 613 static void
 614 thread_db_detach (char *args, int from_tty)
 615 {
 616   disable_thread_event_reporting ();
 617
 618   /* There's no need to save & restore inferior_ptid here, since the
 619      inferior is supposed to be survive this function call.  */
 620   inferior_ptid = lwp_from_thread (inferior_ptid);
 621
 622   /* Forget about the child's process ID.  We shouldn't need it
 623      anymore.  */
 624   proc_handle.pid = 0;
 625
 626   target_beneath->to_detach (args, from_tty);
 627 }
 628
 629 static void
 630 thread_db_resume (ptid_t ptid, int step, enum target_signal signo)
 631 {
 632   struct cleanup *old_chain = save_inferior_ptid ();
 633
 634   if (GET_PID (ptid) == -1)
 635     inferior_ptid = lwp_from_thread (inferior_ptid);
 636   else if (is_thread (ptid))
 637     ptid = lwp_from_thread (ptid);
 638
 639   target_beneath->to_resume (ptid, step, signo);
 640
 641   do_cleanups (old_chain);
 642 }
 643
 644 /* Check if PID is currently stopped at the location of a thread event
 645    breakpoint location.  If it is, read the event message and act upon
 646    the event.  */
 647
 648 static void
 649 check_event (ptid_t ptid)
 650 {
 651   td_event_msg_t msg;
 652   td_thrinfo_t ti;
 653   td_err_e err;
 654   CORE_ADDR stop_pc;
 655
 656   /* Bail out early if we're not at a thread event breakpoint.  */
 657   stop_pc = read_pc_pid (ptid) - DECR_PC_AFTER_BREAK;
 658   if (stop_pc != td_create_bp_addr && stop_pc != td_death_bp_addr)
 659     return;
 660
 661   err = td_ta_event_getmsg_p (thread_agent, &msg);
 662   if (err != TD_OK)
 663     {
 664       if (err == TD_NOMSG)
 665         return;
 666
 667       error ("Cannot get thread event message: %s", thread_db_err_str (err));
 668     }
 669
 670   err = td_thr_get_info_p (msg.th_p, &ti);
 671   if (err != TD_OK)
 672     error ("Cannot get thread info: %s", thread_db_err_str (err));
 673
 674   ptid = BUILD_THREAD (ti.ti_tid, GET_PID (ptid));
 675
 676   switch (msg.event)
 677     {
 678     case TD_CREATE:
 679 #if 0
 680       /* FIXME: kettenis/2000-08-26: Since we use td_ta_event_getmsg,
 681          there is no guarantee that the breakpoint will match the
 682          event.  Should we use td_thr_event_getmsg instead?  */
 683
 684       if (stop_pc != td_create_bp_addr)
 685         error ("Thread creation event doesn't match breakpoint.");
 686 #endif
 687
 688       /* We may already know about this thread, for instance when the
 689          user has issued the `info threads' command before the SIGTRAP
 690          for hitting the thread creation breakpoint was reported.  */
 691       if (!in_thread_list (ptid))
 692         attach_thread (ptid, msg.th_p, &ti, 1);
 693       return;
 694
 695     case TD_DEATH:
 696 #if 0
 697       /* FIXME: See TD_CREATE.  */
 698
 699       if (stop_pc != td_death_bp_addr)
 700         error ("Thread death event doesn't match breakpoint.");
 701 #endif
 702
 703       if (!in_thread_list (ptid))
 704         error ("Spurious thread death event.");
 705
 706       detach_thread (ptid, 1);
 707       return;
 708
 709     default:
 710       error ("Spurious thread event.");
 711     }
 712 }
 713
 714 static ptid_t
 715 thread_db_wait (ptid_t ptid, struct target_waitstatus *ourstatus)
 716 {
 717   extern ptid_t trap_ptid;
 718
 719   if (GET_PID (ptid) != -1 && is_thread (ptid))
 720     ptid = lwp_from_thread (ptid);
 721
 722   ptid = target_beneath->to_wait (ptid, ourstatus);
 723
 724   if (proc_handle.pid == 0)
 725     /* The current child process isn't the actual multi-threaded
 726        program yet, so don't try to do any special thread-specific
 727        post-processing and bail out early.  */
 728     return ptid;
 729
 730   if (ourstatus->kind == TARGET_WAITKIND_EXITED)
 731     return pid_to_ptid (-1);
 732
 733   if (ourstatus->kind == TARGET_WAITKIND_STOPPED
 734       && ourstatus->value.sig == TARGET_SIGNAL_TRAP)
 735     /* Check for a thread event.  */
 736     check_event (ptid);
 737
 738   if (!ptid_equal (trap_ptid, null_ptid))
 739     trap_ptid = thread_from_lwp (trap_ptid);
 740
 741   return thread_from_lwp (ptid);
 742 }
 743
 744 static int
 745 thread_db_xfer_memory (CORE_ADDR memaddr, char *myaddr, int len, int write,
 746                        struct mem_attrib *attrib,
 747                        struct target_ops *target)
 748 {
 749   struct cleanup *old_chain = save_inferior_ptid ();
 750   int xfer;
 751
 752   if (is_thread (inferior_ptid))
 753     {
 754       /* FIXME: This seems to be necessary to make sure breakpoints
 755          are removed.  */
 756       if (!target_thread_alive (inferior_ptid))
 757         inferior_ptid = pid_to_ptid (GET_PID (inferior_ptid));
 758       else
 759         inferior_ptid = lwp_from_thread (inferior_ptid);
 760     }
 761
 762   xfer = target_beneath->to_xfer_memory (memaddr, myaddr, len, write, attrib, target);
 763
 764   do_cleanups (old_chain);
 765   return xfer;
 766 }
 767
 768 static void
 769 thread_db_fetch_registers (int regno)
 770 {
 771   td_thrhandle_t th;
 772   prgregset_t gregset;
 773   gdb_prfpregset_t fpregset;
 774   td_err_e err;
 775
 776   if (!is_thread (inferior_ptid))
 777     {
 778       /* Pass the request to the target beneath us.  */
 779       target_beneath->to_fetch_registers (regno);
 780       return;
 781     }
 782
 783   err = td_ta_map_id2thr_p (thread_agent, GET_THREAD (inferior_ptid), &th);
 784   if (err != TD_OK)
 785     error ("Cannot find thread %ld: %s",
 786            (long) GET_THREAD (inferior_ptid), thread_db_err_str (err));
 787
 788   err = td_thr_getgregs_p (&th, gregset);
 789   if (err != TD_OK)
 790     error ("Cannot fetch general-purpose registers for thread %ld: %s",
 791            (long) GET_THREAD (inferior_ptid), thread_db_err_str (err));
 792
 793   err = td_thr_getfpregs_p (&th, &fpregset);
 794   if (err != TD_OK)
 795     error ("Cannot get floating-point registers for thread %ld: %s",
 796            (long) GET_THREAD (inferior_ptid), thread_db_err_str (err));
 797
 798   /* Note that we must call supply_gregset after calling the thread_db
 799      routines because the thread_db routines call ps_lgetgregs and
 800      friends which clobber GDB's register cache.  */
 801   supply_gregset ((gdb_gregset_t *) gregset);
 802   supply_fpregset (&fpregset);
 803 }
 804
 805 static void
 806 thread_db_store_registers (int regno)
 807 {
 808   td_thrhandle_t th;
 809   prgregset_t gregset;
 810   gdb_prfpregset_t fpregset;
 811   td_err_e err;
 812
 813   if (!is_thread (inferior_ptid))
 814     {
 815       /* Pass the request to the target beneath us.  */
 816       target_beneath->to_store_registers (regno);
 817       return;
 818     }
 819
 820   err = td_ta_map_id2thr_p (thread_agent, GET_THREAD (inferior_ptid), &th);
 821   if (err != TD_OK)
 822     error ("Cannot find thread %ld: %s",
 823            (long) GET_THREAD (inferior_ptid), thread_db_err_str (err));
 824
 825   if (regno != -1)
 826     {
 827       char raw[MAX_REGISTER_RAW_SIZE];
 828
 829       read_register_gen (regno, raw);
 830       thread_db_fetch_registers (-1);
 831       supply_register (regno, raw);
 832     }
 833
 834   fill_gregset ((gdb_gregset_t *) gregset, -1);
 835   fill_fpregset (&fpregset, -1);
 836
 837   err = td_thr_setgregs_p (&th, gregset);
 838   if (err != TD_OK)
 839     error ("Cannot store general-purpose registers for thread %ld: %s",
 840            (long) GET_THREAD (inferior_ptid), thread_db_err_str (err));
 841   err = td_thr_setfpregs_p (&th, &fpregset);
 842   if (err != TD_OK)
 843     error ("Cannot store floating-point registers  for thread %ld: %s",
 844            (long) GET_THREAD (inferior_ptid), thread_db_err_str (err));
 845 }
 846
 847 static void
 848 thread_db_kill (void)
 849 {
 850   /* There's no need to save & restore inferior_ptid here, since the
 851      inferior isn't supposed to survive this function call.  */
 852   inferior_ptid = lwp_from_thread (inferior_ptid);
 853   target_beneath->to_kill ();
 854 }
 855
 856 static void
 857 thread_db_create_inferior (char *exec_file, char *allargs, char **env)
 858 {
 859   if (!keep_thread_db)
 860     {
 861       unpush_target (&thread_db_ops);
 862       using_thread_db = 0;
 863     }
 864
 865   target_beneath->to_create_inferior (exec_file, allargs, env);
 866 }
 867
 868 static void
 869 thread_db_post_startup_inferior (ptid_t ptid)
 870 {
 871   if (proc_handle.pid == 0)
 872     {
 873       /* The child process is now the actual multi-threaded
 874          program.  Snatch its process ID...  */
 875       proc_handle.pid = GET_PID (ptid);
 876
 877       /* ...and perform the remaining initialization steps.  */
 878       enable_thread_event_reporting ();
 879       thread_db_find_new_threads ();
 880     }
 881 }
 882
 883 static void
 884 thread_db_mourn_inferior (void)
 885 {
 886   remove_thread_event_breakpoints ();
 887
 888   /* Forget about the child's process ID.  We shouldn't need it
 889      anymore.  */
 890   proc_handle.pid = 0;
 891
 892   target_beneath->to_mourn_inferior ();
 893 }
 894
 895 static int
 896 thread_db_thread_alive (ptid_t ptid)
 897 {
 898   td_thrhandle_t th;
 899   td_thrinfo_t ti;
 900   td_err_e err;
 901
 902   if (is_thread (ptid))
 903     {
 904       err = td_ta_map_id2thr_p (thread_agent, GET_THREAD (ptid), &th);
 905       if (err != TD_OK)
 906         return 0;
 907
 908       err = td_thr_validate_p (&th);
 909       if (err != TD_OK)
 910         return 0;
 911
 912       err = td_thr_get_info_p (&th, &ti);
 913       if (err != TD_OK)
 914         return 0;
 915
 916       if (ti.ti_state == TD_THR_UNKNOWN || ti.ti_state == TD_THR_ZOMBIE)
 917         return 0;               /* A zombie thread.  */
 918
 919       return 1;
 920     }
 921
 922   if (target_beneath->to_thread_alive)
 923     return target_beneath->to_thread_alive (ptid);
 924
 925   return 0;
 926 }
 927
 928 static int
 929 find_new_threads_callback (const td_thrhandle_t *th_p, void *data)
 930 {
 931   td_thrinfo_t ti;
 932   td_err_e err;
 933   ptid_t ptid;
 934
 935   err = td_thr_get_info_p (th_p, &ti);
 936   if (err != TD_OK)
 937     error ("Cannot get thread info: %s", thread_db_err_str (err));
 938
 939   if (ti.ti_state == TD_THR_UNKNOWN || ti.ti_state == TD_THR_ZOMBIE)
 940     return 0;                   /* A zombie -- ignore.  */
 941
 942   ptid = BUILD_THREAD (ti.ti_tid, GET_PID (inferior_ptid));
 943
 944   if (!in_thread_list (ptid))
 945     attach_thread (ptid, th_p, &ti, 1);
 946
 947   return 0;
 948 }
 949
 950 static void
 951 thread_db_find_new_threads (void)
 952 {
 953   td_err_e err;
 954
 955   /* Iterate over all user-space threads to discover new threads.  */
 956   err = td_ta_thr_iter_p (thread_agent, find_new_threads_callback, NULL,
 957                           TD_THR_ANY_STATE, TD_THR_LOWEST_PRIORITY,
 958                           TD_SIGNO_MASK, TD_THR_ANY_USER_FLAGS);
 959   if (err != TD_OK)
 960     error ("Cannot find new threads: %s", thread_db_err_str (err));
 961 }
 962
 963 static char *
 964 thread_db_pid_to_str (ptid_t ptid)
 965 {
 966   if (is_thread (ptid))
 967     {
 968       static char buf[64];
 969       td_thrhandle_t th;
 970       td_thrinfo_t ti;
 971       td_err_e err;
 972
 973       err = td_ta_map_id2thr_p (thread_agent, GET_THREAD (ptid), &th);
 974       if (err != TD_OK)
 975         error ("Cannot find thread %ld: %s",
 976                (long) GET_THREAD (ptid), thread_db_err_str (err));
 977
 978       err = td_thr_get_info_p (&th, &ti);
 979       if (err != TD_OK)
 980         error ("Cannot get thread info for thread %ld: %s",
 981                (long) GET_THREAD (ptid), thread_db_err_str (err));
 982
 983       if (ti.ti_state == TD_THR_ACTIVE && ti.ti_lid != 0)
 984         {
 985           snprintf (buf, sizeof (buf), "Thread %ld (LWP %d)",
 986                     (long) ti.ti_tid, ti.ti_lid);
 987         }
 988       else
 989         {
 990           snprintf (buf, sizeof (buf), "Thread %ld (%s)",
 991                     (long) ti.ti_tid, thread_db_state_str (ti.ti_state));
 992         }
 993
 994       return buf;
 995     }
 996
 997   if (target_beneath->to_pid_to_str (ptid))
 998     return target_beneath->to_pid_to_str (ptid);
 999
1000   return normal_pid_to_str (ptid);
1001 }
1002
1003 static void
1004 init_thread_db_ops (void)
1005 {
1006   thread_db_ops.to_shortname = "multi-thread";
1007   thread_db_ops.to_longname = "multi-threaded child process.";
1008   thread_db_ops.to_doc = "Threads and pthreads support.";
1009   thread_db_ops.to_attach = thread_db_attach;
1010   thread_db_ops.to_detach = thread_db_detach;
1011   thread_db_ops.to_resume = thread_db_resume;
1012   thread_db_ops.to_wait = thread_db_wait;
1013   thread_db_ops.to_fetch_registers = thread_db_fetch_registers;
1014   thread_db_ops.to_store_registers = thread_db_store_registers;
1015   thread_db_ops.to_xfer_memory = thread_db_xfer_memory;
1016   thread_db_ops.to_kill = thread_db_kill;
1017   thread_db_ops.to_create_inferior = thread_db_create_inferior;
1018   thread_db_ops.to_post_startup_inferior = thread_db_post_startup_inferior;
1019   thread_db_ops.to_mourn_inferior = thread_db_mourn_inferior;
1020   thread_db_ops.to_thread_alive = thread_db_thread_alive;
1021   thread_db_ops.to_find_new_threads = thread_db_find_new_threads;
1022   thread_db_ops.to_pid_to_str = thread_db_pid_to_str;
1023   thread_db_ops.to_stratum = thread_stratum;
1024   thread_db_ops.to_has_thread_control = tc_schedlock;
1025   thread_db_ops.to_magic = OPS_MAGIC;
1026 }
1027
1028 void
1029 _initialize_thread_db (void)
1030 {
1031   /* Only initialize the module if we can load libthread_db.  */
1032   if (thread_db_load ())
1033     {
1034       init_thread_db_ops ();
1035       add_target (&thread_db_ops);
1036
1037       /* Add ourselves to objfile event chain.  */
1038       target_new_objfile_chain = target_new_objfile_hook;
1039       target_new_objfile_hook = thread_db_new_objfile;
1040     }
1041 }