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 int
 379 thread_db_load (void)
 380 {
 381   void *handle;
 382   td_err_e err;
 383
 384   handle = dlopen (LIBTHREAD_DB_SO, RTLD_NOW);
 385   if (handle == NULL)
 386     {
 387       fprintf_filtered (gdb_stderr, "\n\ndlopen failed on '%s' - %s\n",
 388                         LIBTHREAD_DB_SO, dlerror ());
 389       fprintf_filtered (gdb_stderr,
 390                         "GDB will not be able to debug pthreads.\n\n");
 391       return 0;
 392     }
 393
 394   /* Initialize pointers to the dynamic library functions we will use.
 395      Essential functions first.  */
 396
 397   td_init_p = dlsym (handle, "td_init");
 398   if (td_init_p == NULL)
 399     return 0;
 400
 401   td_ta_new_p = dlsym (handle, "td_ta_new");
 402   if (td_ta_new_p == NULL)
 403     return 0;
 404
 405   td_ta_map_id2thr_p = dlsym (handle, "td_ta_map_id2thr");
 406   if (td_ta_map_id2thr_p == NULL)
 407     return 0;
 408
 409   td_ta_map_lwp2thr_p = dlsym (handle, "td_ta_map_lwp2thr");
 410   if (td_ta_map_lwp2thr_p == NULL)
 411     return 0;
 412
 413   td_ta_thr_iter_p = dlsym (handle, "td_ta_thr_iter");
 414   if (td_ta_thr_iter_p == NULL)
 415     return 0;
 416
 417   td_thr_validate_p = dlsym (handle, "td_thr_validate");
 418   if (td_thr_validate_p == NULL)
 419     return 0;
 420
 421   td_thr_get_info_p = dlsym (handle, "td_thr_get_info");
 422   if (td_thr_get_info_p == NULL)
 423     return 0;
 424
 425   td_thr_getfpregs_p = dlsym (handle, "td_thr_getfpregs");
 426   if (td_thr_getfpregs_p == NULL)
 427     return 0;
 428
 429   td_thr_getgregs_p = dlsym (handle, "td_thr_getgregs");
 430   if (td_thr_getgregs_p == NULL)
 431     return 0;
 432
 433   td_thr_setfpregs_p = dlsym (handle, "td_thr_setfpregs");
 434   if (td_thr_setfpregs_p == NULL)
 435     return 0;
 436
 437   td_thr_setgregs_p = dlsym (handle, "td_thr_setgregs");
 438   if (td_thr_setgregs_p == NULL)
 439     return 0;
 440
 441   /* Initialize the library.  */
 442   err = td_init_p ();
 443   if (err != TD_OK)
 444     {
 445       warning ("Cannot initialize libthread_db: %s", thread_db_err_str (err));
 446       return 0;
 447     }
 448
 449   /* These are not essential.  */
 450   td_ta_event_addr_p = dlsym (handle, "td_ta_event_addr");
 451   td_ta_set_event_p = dlsym (handle, "td_ta_set_event");
 452   td_ta_event_getmsg_p = dlsym (handle, "td_ta_event_getmsg");
 453   td_thr_event_enable_p = dlsym (handle, "td_thr_event_enable");
 454   td_thr_tls_get_addr_p = dlsym (handle, "td_thr_tls_get_addr");
 455
 456   return 1;
 457 }
 458
 459 static void
 460 enable_thread_event_reporting (void)
 461 {
 462   td_thr_events_t events;
 463   td_notify_t notify;
 464   td_err_e err;
 465
 466   /* We cannot use the thread event reporting facility if these
 467      functions aren't available.  */
 468   if (td_ta_event_addr_p == NULL || td_ta_set_event_p == NULL
 469       || td_ta_event_getmsg_p == NULL || td_thr_event_enable_p == NULL)
 470     return;
 471
 472   /* Set the process wide mask saying which events we're interested in.  */
 473   td_event_emptyset (&events);
 474   td_event_addset (&events, TD_CREATE);
 475 #if 0
 476   /* FIXME: kettenis/2000-04-23: The event reporting facility is
 477      broken for TD_DEATH events in glibc 2.1.3, so don't enable it for
 478      now.  */
 479   td_event_addset (&events, TD_DEATH);
 480 #endif
 481
 482   err = td_ta_set_event_p (thread_agent, &events);
 483   if (err != TD_OK)
 484     {
 485       warning ("Unable to set global thread event mask: %s",
 486                thread_db_err_str (err));
 487       return;
 488     }
 489
 490   /* Delete previous thread event breakpoints, if any.  */
 491   remove_thread_event_breakpoints ();
 492
 493   /* Get address for thread creation breakpoint.  */
 494   err = td_ta_event_addr_p (thread_agent, TD_CREATE, &notify);
 495   if (err != TD_OK)
 496     {
 497       warning ("Unable to get location for thread creation breakpoint: %s",
 498                thread_db_err_str (err));
 499       return;
 500     }
 501
 502   /* Set up the breakpoint.  */
 503   td_create_bp_addr = (CORE_ADDR) notify.u.bptaddr;
 504   create_thread_event_breakpoint (td_create_bp_addr);
 505
 506   /* Get address for thread death breakpoint.  */
 507   err = td_ta_event_addr_p (thread_agent, TD_DEATH, &notify);
 508   if (err != TD_OK)
 509     {
 510       warning ("Unable to get location for thread death breakpoint: %s",
 511                thread_db_err_str (err));
 512       return;
 513     }
 514
 515   /* Set up the breakpoint.  */
 516   td_death_bp_addr = (CORE_ADDR) notify.u.bptaddr;
 517   create_thread_event_breakpoint (td_death_bp_addr);
 518 }
 519
 520 static void
 521 disable_thread_event_reporting (void)
 522 {
 523   td_thr_events_t events;
 524
 525   /* Set the process wide mask saying we aren't interested in any
 526      events anymore.  */
 527   td_event_emptyset (&events);
 528   td_ta_set_event_p (thread_agent, &events);
 529
 530   /* Delete thread event breakpoints, if any.  */
 531   remove_thread_event_breakpoints ();
 532   td_create_bp_addr = 0;
 533   td_death_bp_addr = 0;
 534 }
 535
 536 static void
 537 check_thread_signals (void)
 538 {
 539 #ifdef GET_THREAD_SIGNALS
 540   if (!thread_signals)
 541     {
 542       sigset_t mask;
 543       int i;
 544
 545       GET_THREAD_SIGNALS (&mask);
 546       sigemptyset (&thread_stop_set);
 547       sigemptyset (&thread_print_set);
 548
 549       for (i = 1; i < NSIG; i++)
 550         {
 551           if (sigismember (&mask, i))
 552             {
 553               if (signal_stop_update (target_signal_from_host (i), 0))
 554                 sigaddset (&thread_stop_set, i);
 555               if (signal_print_update (target_signal_from_host (i), 0))
 556                 sigaddset (&thread_print_set, i);
 557               thread_signals = 1;
 558             }
 559         }
 560     }
 561 #endif
 562 }
 563
 564 static void
 565 disable_thread_signals (void)
 566 {
 567 #ifdef GET_THREAD_SIGNALS
 568   if (thread_signals)
 569     {
 570       int i;
 571
 572       for (i = 1; i < NSIG; i++)
 573         {
 574           if (sigismember (&thread_stop_set, i))
 575             signal_stop_update (target_signal_from_host (i), 1);
 576           if (sigismember (&thread_print_set, i))
 577             signal_print_update (target_signal_from_host (i), 1);
 578         }
 579
 580       thread_signals = 0;
 581     }
 582 #endif
 583 }
 584
 585 static void
 586 thread_db_new_objfile (struct objfile *objfile)
 587 {
 588   td_err_e err;
 589
 590   /* Don't attempt to use thread_db on targets which can not run
 591      (core files).  */
 592   if (objfile == NULL || !target_has_execution)
 593     {
 594       /* All symbols have been discarded.  If the thread_db target is
 595          active, deactivate it now.  */
 596       if (using_thread_db)
 597         {
 598           gdb_assert (proc_handle.pid == 0);
 599           unpush_target (&thread_db_ops);
 600           using_thread_db = 0;
 601         }
 602
 603       keep_thread_db = 0;
 604
 605       goto quit;
 606     }
 607
 608   if (using_thread_db)
 609     /* Nothing to do.  The thread library was already detected and the
 610        target vector was already activated.  */
 611     goto quit;
 612
 613   /* Initialize the structure that identifies the child process.  Note
 614      that at this point there is no guarantee that we actually have a
 615      child process.  */
 616   proc_handle.pid = GET_PID (inferior_ptid);
 617
 618   /* Now attempt to open a connection to the thread library.  */
 619   err = td_ta_new_p (&proc_handle, &thread_agent);
 620   switch (err)
 621     {
 622     case TD_NOLIBTHREAD:
 623       /* No thread library was detected.  */
 624       break;
 625
 626     case TD_OK:
 627       /* The thread library was detected.  Activate the thread_db target.  */
 628       push_target (&thread_db_ops);
 629       using_thread_db = 1;
 630
 631       /* If the thread library was detected in the main symbol file
 632          itself, we assume that the program was statically linked
 633          against the thread library and well have to keep this
 634          module's target vector activated until forever...  Well, at
 635          least until all symbols have been discarded anyway (see
 636          above).  */
 637       if (objfile == symfile_objfile)
 638         {
 639           gdb_assert (proc_handle.pid == 0);
 640           keep_thread_db = 1;
 641         }
 642
 643       /* We can only poke around if there actually is a child process.
 644          If there is no child process alive, postpone the steps below
 645          until one has been created.  */
 646       if (proc_handle.pid != 0)
 647         {
 648           enable_thread_event_reporting ();
 649           thread_db_find_new_threads ();
 650         }
 651       break;
 652
 653     default:
 654       warning ("Cannot initialize thread debugging library: %s",
 655                thread_db_err_str (err));
 656       break;
 657     }
 658
 659 quit:
 660   if (target_new_objfile_chain)
 661     target_new_objfile_chain (objfile);
 662 }
 663
 664 static void
 665 attach_thread (ptid_t ptid, const td_thrhandle_t *th_p,
 666                const td_thrinfo_t *ti_p, int verbose)
 667 {
 668   struct thread_info *tp;
 669   td_err_e err;
 670
 671   check_thread_signals ();
 672
 673   /* Add the thread to GDB's thread list.  */
 674   tp = add_thread (ptid);
 675   tp->private = xmalloc (sizeof (struct private_thread_info));
 676   memset (tp->private, 0, sizeof (struct private_thread_info));
 677
 678   if (verbose)
 679     printf_unfiltered ("[New %s]\n", target_pid_to_str (ptid));
 680
 681   if (ti_p->ti_state == TD_THR_UNKNOWN || ti_p->ti_state == TD_THR_ZOMBIE)
 682     return;                     /* A zombie thread -- do not attach.  */
 683
 684   /* Under GNU/Linux, we have to attach to each and every thread.  */
 685 #ifdef ATTACH_LWP
 686   ATTACH_LWP (BUILD_LWP (ti_p->ti_lid, GET_PID (ptid)), 0);
 687 #endif
 688
 689   /* Enable thread event reporting for this thread.  */
 690   err = td_thr_event_enable_p (th_p, 1);
 691   if (err != TD_OK)
 692     error ("Cannot enable thread event reporting for %s: %s",
 693            target_pid_to_str (ptid), thread_db_err_str (err));
 694 }
 695
 696 static void
 697 thread_db_attach (char *args, int from_tty)
 698 {
 699   target_beneath->to_attach (args, from_tty);
 700
 701   /* Destroy thread info; it's no longer valid.  */
 702   init_thread_list ();
 703
 704   /* The child process is now the actual multi-threaded
 705      program.  Snatch its process ID...  */
 706   proc_handle.pid = GET_PID (inferior_ptid);
 707
 708   /* ...and perform the remaining initialization steps.  */
 709   enable_thread_event_reporting ();
 710   thread_db_find_new_threads ();
 711 }
 712
 713 static void
 714 detach_thread (ptid_t ptid, int verbose)
 715 {
 716   if (verbose)
 717     printf_unfiltered ("[%s exited]\n", target_pid_to_str (ptid));
 718 }
 719
 720 static void
 721 thread_db_detach (char *args, int from_tty)
 722 {
 723   disable_thread_event_reporting ();
 724
 725   /* There's no need to save & restore inferior_ptid here, since the
 726      inferior is supposed to be survive this function call.  */
 727   inferior_ptid = lwp_from_thread (inferior_ptid);
 728
 729   /* Forget about the child's process ID.  We shouldn't need it
 730      anymore.  */
 731   proc_handle.pid = 0;
 732
 733   target_beneath->to_detach (args, from_tty);
 734 }
 735
 736 static int
 737 clear_lwpid_callback (struct thread_info *thread, void *dummy)
 738 {
 739   /* If we know that our thread implementation is 1-to-1, we could save
 740      a certain amount of information; it's not clear how much, so we
 741      are always conservative.  */
 742
 743   thread->private->th_valid = 0;
 744   thread->private->ti_valid = 0;
 745
 746   return 0;
 747 }
 748
 749 static void
 750 thread_db_resume (ptid_t ptid, int step, enum target_signal signo)
 751 {
 752   struct cleanup *old_chain = save_inferior_ptid ();
 753
 754   if (GET_PID (ptid) == -1)
 755     inferior_ptid = lwp_from_thread (inferior_ptid);
 756   else if (is_thread (ptid))
 757     ptid = lwp_from_thread (ptid);
 758
 759   /* Clear cached data which may not be valid after the resume.  */
 760   iterate_over_threads (clear_lwpid_callback, NULL);
 761
 762   target_beneath->to_resume (ptid, step, signo);
 763
 764   do_cleanups (old_chain);
 765 }
 766
 767 /* Check if PID is currently stopped at the location of a thread event
 768    breakpoint location.  If it is, read the event message and act upon
 769    the event.  */
 770
 771 static void
 772 check_event (ptid_t ptid)
 773 {
 774   td_event_msg_t msg;
 775   td_thrinfo_t ti;
 776   td_err_e err;
 777   CORE_ADDR stop_pc;
 778   int loop = 0;
 779
 780   /* Bail out early if we're not at a thread event breakpoint.  */
 781   stop_pc = read_pc_pid (ptid) - DECR_PC_AFTER_BREAK;
 782   if (stop_pc != td_create_bp_addr && stop_pc != td_death_bp_addr)
 783     return;
 784
 785   /* If we are at a create breakpoint, we do not know what new lwp
 786      was created and cannot specifically locate the event message for it.
 787      We have to call td_ta_event_getmsg() to get
 788      the latest message.  Since we have no way of correlating whether
 789      the event message we get back corresponds to our breakpoint, we must
 790      loop and read all event messages, processing them appropriately.
 791      This guarantees we will process the correct message before continuing
 792      from the breakpoint.
 793
 794      Currently, death events are not enabled.  If they are enabled,
 795      the death event can use the td_thr_event_getmsg() interface to
 796      get the message specifically for that lwp and avoid looping
 797      below.  */
 798
 799   loop = 1;
 800
 801   do
 802     {
 803       err = td_ta_event_getmsg_p (thread_agent, &msg);
 804       if (err != TD_OK)
 805         {
 806           if (err == TD_NOMSG)
 807             return;
 808
 809           error ("Cannot get thread event message: %s",
 810                  thread_db_err_str (err));
 811         }
 812
 813       err = td_thr_get_info_p (msg.th_p, &ti);
 814       if (err != TD_OK)
 815         error ("Cannot get thread info: %s", thread_db_err_str (err));
 816
 817       ptid = BUILD_THREAD (ti.ti_tid, GET_PID (ptid));
 818
 819       switch (msg.event)
 820         {
 821         case TD_CREATE:
 822
 823           /* We may already know about this thread, for instance when the
 824              user has issued the `info threads' command before the SIGTRAP
 825              for hitting the thread creation breakpoint was reported.  */
 826           if (!in_thread_list (ptid))
 827             attach_thread (ptid, msg.th_p, &ti, 1);
 828
 829           break;
 830
 831         case TD_DEATH:
 832
 833           if (!in_thread_list (ptid))
 834             error ("Spurious thread death event.");
 835
 836           detach_thread (ptid, 1);
 837
 838           break;
 839
 840         default:
 841           error ("Spurious thread event.");
 842         }
 843     }
 844   while (loop);
 845 }
 846
 847 static ptid_t
 848 thread_db_wait (ptid_t ptid, struct target_waitstatus *ourstatus)
 849 {
 850   extern ptid_t trap_ptid;
 851
 852   if (GET_PID (ptid) != -1 && is_thread (ptid))
 853     ptid = lwp_from_thread (ptid);
 854
 855   ptid = target_beneath->to_wait (ptid, ourstatus);
 856
 857   if (proc_handle.pid == 0)
 858     /* The current child process isn't the actual multi-threaded
 859        program yet, so don't try to do any special thread-specific
 860        post-processing and bail out early.  */
 861     return ptid;
 862
 863   if (ourstatus->kind == TARGET_WAITKIND_EXITED)
 864     return pid_to_ptid (-1);
 865
 866   if (ourstatus->kind == TARGET_WAITKIND_STOPPED
 867       && ourstatus->value.sig == TARGET_SIGNAL_TRAP)
 868     /* Check for a thread event.  */
 869     check_event (ptid);
 870
 871   if (!ptid_equal (trap_ptid, null_ptid))
 872     trap_ptid = thread_from_lwp (trap_ptid);
 873
 874   return thread_from_lwp (ptid);
 875 }
 876
 877 static int
 878 thread_db_xfer_memory (CORE_ADDR memaddr, char *myaddr, int len, int write,
 879                        struct mem_attrib *attrib, struct target_ops *target)
 880 {
 881   struct cleanup *old_chain = save_inferior_ptid ();
 882   int xfer;
 883
 884   if (is_thread (inferior_ptid))
 885     {
 886       /* FIXME: This seems to be necessary to make sure breakpoints
 887          are removed.  */
 888       if (!target_thread_alive (inferior_ptid))
 889         inferior_ptid = pid_to_ptid (GET_PID (inferior_ptid));
 890       else
 891         inferior_ptid = lwp_from_thread (inferior_ptid);
 892     }
 893
 894   xfer =
 895     target_beneath->to_xfer_memory (memaddr, myaddr, len, write, attrib,
 896                                     target);
 897
 898   do_cleanups (old_chain);
 899   return xfer;
 900 }
 901
 902 static void
 903 thread_db_fetch_registers (int regno)
 904 {
 905   struct thread_info *thread_info;
 906   prgregset_t gregset;
 907   gdb_prfpregset_t fpregset;
 908   td_err_e err;
 909
 910   if (!is_thread (inferior_ptid))
 911     {
 912       /* Pass the request to the target beneath us.  */
 913       target_beneath->to_fetch_registers (regno);
 914       return;
 915     }
 916
 917   thread_info = find_thread_pid (inferior_ptid);
 918   thread_db_map_id2thr (thread_info, 1);
 919
 920   err = td_thr_getgregs_p (&thread_info->private->th, gregset);
 921   if (err != TD_OK)
 922     error ("Cannot fetch general-purpose registers for thread %ld: %s",
 923            (long) GET_THREAD (inferior_ptid), thread_db_err_str (err));
 924
 925   err = td_thr_getfpregs_p (&thread_info->private->th, &fpregset);
 926   if (err != TD_OK)
 927     error ("Cannot get floating-point registers for thread %ld: %s",
 928            (long) GET_THREAD (inferior_ptid), thread_db_err_str (err));
 929
 930   /* Note that we must call supply_gregset after calling the thread_db
 931      routines because the thread_db routines call ps_lgetgregs and
 932      friends which clobber GDB's register cache.  */
 933   supply_gregset ((gdb_gregset_t *) gregset);
 934   supply_fpregset (&fpregset);
 935 }
 936
 937 static void
 938 thread_db_store_registers (int regno)
 939 {
 940   prgregset_t gregset;
 941   gdb_prfpregset_t fpregset;
 942   td_err_e err;
 943   struct thread_info *thread_info;
 944
 945   if (!is_thread (inferior_ptid))
 946     {
 947       /* Pass the request to the target beneath us.  */
 948       target_beneath->to_store_registers (regno);
 949       return;
 950     }
 951
 952   thread_info = find_thread_pid (inferior_ptid);
 953   thread_db_map_id2thr (thread_info, 1);
 954
 955   if (regno != -1)
 956     {
 957       char raw[MAX_REGISTER_SIZE];
 958
 959       deprecated_read_register_gen (regno, raw);
 960       thread_db_fetch_registers (-1);
 961       supply_register (regno, raw);
 962     }
 963
 964   fill_gregset ((gdb_gregset_t *) gregset, -1);
 965   fill_fpregset (&fpregset, -1);
 966
 967   err = td_thr_setgregs_p (&thread_info->private->th, gregset);
 968   if (err != TD_OK)
 969     error ("Cannot store general-purpose registers for thread %ld: %s",
 970            (long) GET_THREAD (inferior_ptid), thread_db_err_str (err));
 971   err = td_thr_setfpregs_p (&thread_info->private->th, &fpregset);
 972   if (err != TD_OK)
 973     error ("Cannot store floating-point registers  for thread %ld: %s",
 974            (long) GET_THREAD (inferior_ptid), thread_db_err_str (err));
 975 }
 976
 977 static void
 978 thread_db_kill (void)
 979 {
 980   /* There's no need to save & restore inferior_ptid here, since the
 981      inferior isn't supposed to survive this function call.  */
 982   inferior_ptid = lwp_from_thread (inferior_ptid);
 983   target_beneath->to_kill ();
 984 }
 985
 986 static void
 987 thread_db_create_inferior (char *exec_file, char *allargs, char **env)
 988 {
 989   if (!keep_thread_db)
 990     {
 991       unpush_target (&thread_db_ops);
 992       using_thread_db = 0;
 993     }
 994
 995   target_beneath->to_create_inferior (exec_file, allargs, env);
 996 }
 997
 998 static void
 999 thread_db_post_startup_inferior (ptid_t ptid)
1000 {
1001   if (proc_handle.pid == 0)
1002     {
1003       /* The child process is now the actual multi-threaded
1004          program.  Snatch its process ID...  */
1005       proc_handle.pid = GET_PID (ptid);
1006
1007       /* ...and perform the remaining initialization steps.  */
1008       enable_thread_event_reporting ();
1009       thread_db_find_new_threads ();
1010     }
1011 }
1012
1013 static void
1014 thread_db_mourn_inferior (void)
1015 {
1016   remove_thread_event_breakpoints ();
1017
1018   /* Forget about the child's process ID.  We shouldn't need it
1019      anymore.  */
1020   proc_handle.pid = 0;
1021
1022   target_beneath->to_mourn_inferior ();
1023
1024   /* Detach thread_db target ops if not dealing with a statically
1025      linked threaded program.  This allows a corefile to be debugged
1026      after finishing debugging of a threaded program.  At present,
1027      debugging a statically-linked threaded program is broken, but
1028      the check is added below in the event that it is fixed in the
1029      future.  */
1030   if (!keep_thread_db)
1031     {
1032       unpush_target (&thread_db_ops);
1033       using_thread_db = 0;
1034     }
1035 }
1036
1037 static int
1038 thread_db_thread_alive (ptid_t ptid)
1039 {
1040   td_thrhandle_t th;
1041   td_err_e err;
1042
1043   if (is_thread (ptid))
1044     {
1045       struct thread_info *thread_info;
1046       thread_info = find_thread_pid (ptid);
1047
1048       thread_db_map_id2thr (thread_info, 0);
1049       if (!thread_info->private->th_valid)
1050         return 0;
1051
1052       err = td_thr_validate_p (&thread_info->private->th);
1053       if (err != TD_OK)
1054         return 0;
1055
1056       if (!thread_info->private->ti_valid)
1057         {
1058           err =
1059             td_thr_get_info_p (&thread_info->private->th,
1060                                &thread_info->private->ti);
1061           if (err != TD_OK)
1062             return 0;
1063           thread_info->private->ti_valid = 1;
1064         }
1065
1066       if (thread_info->private->ti.ti_state == TD_THR_UNKNOWN
1067           || thread_info->private->ti.ti_state == TD_THR_ZOMBIE)
1068         return 0;               /* A zombie thread.  */
1069
1070       return 1;
1071     }
1072
1073   if (target_beneath->to_thread_alive)
1074     return target_beneath->to_thread_alive (ptid);
1075
1076   return 0;
1077 }
1078
1079 static int
1080 find_new_threads_callback (const td_thrhandle_t *th_p, void *data)
1081 {
1082   td_thrinfo_t ti;
1083   td_err_e err;
1084   ptid_t ptid;
1085
1086   err = td_thr_get_info_p (th_p, &ti);
1087   if (err != TD_OK)
1088     error ("find_new_threads_callback: cannot get thread info: %s",
1089            thread_db_err_str (err));
1090
1091   if (ti.ti_state == TD_THR_UNKNOWN || ti.ti_state == TD_THR_ZOMBIE)
1092     return 0;                   /* A zombie -- ignore.  */
1093
1094   ptid = BUILD_THREAD (ti.ti_tid, GET_PID (inferior_ptid));
1095
1096   if (!in_thread_list (ptid))
1097     attach_thread (ptid, th_p, &ti, 1);
1098
1099   return 0;
1100 }
1101
1102 static void
1103 thread_db_find_new_threads (void)
1104 {
1105   td_err_e err;
1106
1107   /* Iterate over all user-space threads to discover new threads.  */
1108   err = td_ta_thr_iter_p (thread_agent, find_new_threads_callback, NULL,
1109                           TD_THR_ANY_STATE, TD_THR_LOWEST_PRIORITY,
1110                           TD_SIGNO_MASK, TD_THR_ANY_USER_FLAGS);
1111   if (err != TD_OK)
1112     error ("Cannot find new threads: %s", thread_db_err_str (err));
1113 }
1114
1115 static char *
1116 thread_db_pid_to_str (ptid_t ptid)
1117 {
1118   if (is_thread (ptid))
1119     {
1120       static char buf[64];
1121       td_thrinfo_t *ti_p;
1122       td_err_e err;
1123       struct thread_info *thread_info;
1124
1125       thread_info = find_thread_pid (ptid);
1126       thread_db_map_id2thr (thread_info, 0);
1127       if (!thread_info->private->th_valid)
1128         {
1129           snprintf (buf, sizeof (buf), "Thread %ld (Missing)",
1130                     GET_THREAD (ptid));
1131           return buf;
1132         }
1133
1134       ti_p = thread_db_get_info (thread_info);
1135
1136       if (ti_p->ti_state == TD_THR_ACTIVE && ti_p->ti_lid != 0)
1137         {
1138           snprintf (buf, sizeof (buf), "Thread %ld (LWP %d)",
1139                     (long) ti_p->ti_tid, ti_p->ti_lid);
1140         }
1141       else
1142         {
1143           snprintf (buf, sizeof (buf), "Thread %ld (%s)",
1144                     (long) ti_p->ti_tid,
1145                     thread_db_state_str (ti_p->ti_state));
1146         }
1147
1148       return buf;
1149     }
1150
1151   if (target_beneath->to_pid_to_str (ptid))
1152     return target_beneath->to_pid_to_str (ptid);
1153
1154   return normal_pid_to_str (ptid);
1155 }
1156
1157 /* Get the address of the thread local variable in OBJFILE which is
1158    stored at OFFSET within the thread local storage for thread PTID.  */
1159
1160 static CORE_ADDR
1161 thread_db_get_thread_local_address (ptid_t ptid, struct objfile *objfile,
1162                                     CORE_ADDR offset)
1163 {
1164   if (is_thread (ptid))
1165     {
1166       int objfile_is_library = (objfile->flags & OBJF_SHARED);
1167       td_err_e err;
1168       void *address;
1169       CORE_ADDR lm;
1170       struct thread_info *thread_info;
1171
1172       /* glibc doesn't provide the needed interface.  */
1173       if (!td_thr_tls_get_addr_p)
1174         error ("Cannot find thread-local variables in this thread library.");
1175
1176       /* Get the address of the link map for this objfile.  */
1177       lm = svr4_fetch_objfile_link_map (objfile);
1178
1179       /* Whoops, we couldn't find one. Bail out.  */
1180       if (!lm)
1181         {
1182           if (objfile_is_library)
1183             error ("Cannot find shared library `%s' link_map in dynamic"
1184                    " linker's module list", objfile->name);
1185           else
1186             error ("Cannot find executable file `%s' link_map in dynamic"
1187                    " linker's module list", objfile->name);
1188         }
1189
1190       /* Get info about the thread.  */
1191       thread_info = find_thread_pid (ptid);
1192       thread_db_map_id2thr (thread_info, 1);
1193
1194       /* Finally, get the address of the variable.  */
1195       err = td_thr_tls_get_addr_p (&thread_info->private->th, (void *) lm,
1196                                    offset, &address);
1197
1198 #ifdef THREAD_DB_HAS_TD_NOTALLOC
1199       /* The memory hasn't been allocated, yet.  */
1200       if (err == TD_NOTALLOC)
1201         {
1202           /* Now, if libthread_db provided the initialization image's
1203              address, we *could* try to build a non-lvalue value from
1204              the initialization image.  */
1205           if (objfile_is_library)
1206             error ("The inferior has not yet allocated storage for"
1207                    " thread-local variables in\n"
1208                    "the shared library `%s'\n"
1209                    "for the thread %ld",
1210                    objfile->name, (long) GET_THREAD (ptid));
1211           else
1212             error ("The inferior has not yet allocated storage for"
1213                    " thread-local variables in\n"
1214                    "the executable `%s'\n"
1215                    "for the thread %ld",
1216                    objfile->name, (long) GET_THREAD (ptid));
1217         }
1218 #endif
1219
1220       /* Something else went wrong.  */
1221       if (err != TD_OK)
1222         {
1223           if (objfile_is_library)
1224             error ("Cannot find thread-local storage for thread %ld, "
1225                    "shared library %s:\n%s",
1226                    (long) GET_THREAD (ptid),
1227                    objfile->name, thread_db_err_str (err));
1228           else
1229             error ("Cannot find thread-local storage for thread %ld, "
1230                    "executable file %s:\n%s",
1231                    (long) GET_THREAD (ptid),
1232                    objfile->name, thread_db_err_str (err));
1233         }
1234
1235       /* Cast assuming host == target.  Joy.  */
1236       return (CORE_ADDR) address;
1237     }
1238
1239   if (target_beneath->to_get_thread_local_address)
1240     return target_beneath->to_get_thread_local_address (ptid, objfile,
1241                                                         offset);
1242
1243   error ("Cannot find thread-local values on this target.");
1244 }
1245
1246 static void
1247 init_thread_db_ops (void)
1248 {
1249   thread_db_ops.to_shortname = "multi-thread";
1250   thread_db_ops.to_longname = "multi-threaded child process.";
1251   thread_db_ops.to_doc = "Threads and pthreads support.";
1252   thread_db_ops.to_attach = thread_db_attach;
1253   thread_db_ops.to_detach = thread_db_detach;
1254   thread_db_ops.to_resume = thread_db_resume;
1255   thread_db_ops.to_wait = thread_db_wait;
1256   thread_db_ops.to_fetch_registers = thread_db_fetch_registers;
1257   thread_db_ops.to_store_registers = thread_db_store_registers;
1258   thread_db_ops.to_xfer_memory = thread_db_xfer_memory;
1259   thread_db_ops.to_kill = thread_db_kill;
1260   thread_db_ops.to_create_inferior = thread_db_create_inferior;
1261   thread_db_ops.to_post_startup_inferior = thread_db_post_startup_inferior;
1262   thread_db_ops.to_mourn_inferior = thread_db_mourn_inferior;
1263   thread_db_ops.to_thread_alive = thread_db_thread_alive;
1264   thread_db_ops.to_find_new_threads = thread_db_find_new_threads;
1265   thread_db_ops.to_pid_to_str = thread_db_pid_to_str;
1266   thread_db_ops.to_stratum = thread_stratum;
1267   thread_db_ops.to_has_thread_control = tc_schedlock;
1268   thread_db_ops.to_get_thread_local_address
1269     = thread_db_get_thread_local_address;
1270   thread_db_ops.to_magic = OPS_MAGIC;
1271 }
1272
1273 void
1274 _initialize_thread_db (void)
1275 {
1276   /* Only initialize the module if we can load libthread_db.  */
1277   if (thread_db_load ())
1278     {
1279       init_thread_db_ops ();
1280       add_target (&thread_db_ops);
1281
1282       /* Add ourselves to objfile event chain.  */
1283       target_new_objfile_chain = target_new_objfile_hook;
1284       target_new_objfile_hook = thread_db_new_objfile;
1285     }
1286 }