gdb/linux-thread-db.c

   1 /* libthread_db assisted debugging support, generic parts.
   2
   3    Copyright (C) 1999, 2000, 2001, 2003, 2004, 2005, 2006, 2007, 2008
   4    Free Software Foundation, Inc.
   5
   6    This file is part of GDB.
   7
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 3 of the License, or
  11    (at your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  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 "exceptions.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 #include "gdbcore.h"
  38 #include "observer.h"
  39 #include "linux-nat.h"
  40
  41 #include <signal.h>
  42
  43 #ifdef HAVE_GNU_LIBC_VERSION_H
  44 #include <gnu/libc-version.h>
  45 #endif
  46
  47 #ifndef LIBTHREAD_DB_SO
  48 #define LIBTHREAD_DB_SO "libthread_db.so.1"
  49 #endif
  50
  51 /* GNU/Linux libthread_db support.
  52
  53    libthread_db is a library, provided along with libpthread.so, which
  54    exposes the internals of the thread library to a debugger.  It
  55    allows GDB to find existing threads, new threads as they are
  56    created, thread IDs (usually, the result of pthread_self), and
  57    thread-local variables.
  58
  59    The libthread_db interface originates on Solaris, where it is
  60    both more powerful and more complicated.  This implementation
  61    only works for LinuxThreads and NPTL, the two glibc threading
  62    libraries.  It assumes that each thread is permanently assigned
  63    to a single light-weight process (LWP).
  64
  65    libthread_db-specific information is stored in the "private" field
  66    of struct thread_info.  When the field is NULL we do not yet have
  67    information about the new thread; this could be temporary (created,
  68    but the thread library's data structures do not reflect it yet)
  69    or permanent (created using clone instead of pthread_create).
  70
  71    Process IDs managed by linux-thread-db.c match those used by
  72    linux-nat.c: a common PID for all processes, an LWP ID for each
  73    thread, and no TID.  We save the TID in private.  Keeping it out
  74    of the ptid_t prevents thread IDs changing when libpthread is
  75    loaded or unloaded.  */
  76
  77 /* If we're running on GNU/Linux, we must explicitly attach to any new
  78    threads.  */
  79
  80 /* This module's target vector.  */
  81 static struct target_ops thread_db_ops;
  82
  83 /* The target vector that we call for things this module can't handle.  */
  84 static struct target_ops *target_beneath;
  85
  86 /* Non-zero if we're using this module's target vector.  */
  87 static int using_thread_db;
  88
  89 /* Non-zero if we have determined the signals used by the threads
  90    library.  */
  91 static int thread_signals;
  92 static sigset_t thread_stop_set;
  93 static sigset_t thread_print_set;
  94
  95 /* Structure that identifies the child process for the
  96    <proc_service.h> interface.  */
  97 static struct ps_prochandle proc_handle;
  98
  99 /* Connection to the libthread_db library.  */
 100 static td_thragent_t *thread_agent;
 101
 102 /* Pointers to the libthread_db functions.  */
 103
 104 static td_err_e (*td_init_p) (void);
 105
 106 static td_err_e (*td_ta_new_p) (struct ps_prochandle * ps,
 107                                 td_thragent_t **ta);
 108 static td_err_e (*td_ta_map_id2thr_p) (const td_thragent_t *ta, thread_t pt,
 109                                        td_thrhandle_t *__th);
 110 static td_err_e (*td_ta_map_lwp2thr_p) (const td_thragent_t *ta,
 111                                         lwpid_t lwpid, td_thrhandle_t *th);
 112 static td_err_e (*td_ta_thr_iter_p) (const td_thragent_t *ta,
 113                                      td_thr_iter_f *callback, void *cbdata_p,
 114                                      td_thr_state_e state, int ti_pri,
 115                                      sigset_t *ti_sigmask_p,
 116                                      unsigned int ti_user_flags);
 117 static td_err_e (*td_ta_event_addr_p) (const td_thragent_t *ta,
 118                                        td_event_e event, td_notify_t *ptr);
 119 static td_err_e (*td_ta_set_event_p) (const td_thragent_t *ta,
 120                                       td_thr_events_t *event);
 121 static td_err_e (*td_ta_event_getmsg_p) (const td_thragent_t *ta,
 122                                          td_event_msg_t *msg);
 123
 124 static td_err_e (*td_thr_validate_p) (const td_thrhandle_t *th);
 125 static td_err_e (*td_thr_get_info_p) (const td_thrhandle_t *th,
 126                                       td_thrinfo_t *infop);
 127 static td_err_e (*td_thr_event_enable_p) (const td_thrhandle_t *th,
 128                                           int event);
 129
 130 static td_err_e (*td_thr_tls_get_addr_p) (const td_thrhandle_t *th,
 131                                           void *map_address,
 132                                           size_t offset, void **address);
 133
 134 /* Location of the thread creation event breakpoint.  The code at this
 135    location in the child process will be called by the pthread library
 136    whenever a new thread is created.  By setting a special breakpoint
 137    at this location, GDB can detect when a new thread is created.  We
 138    obtain this location via the td_ta_event_addr call.  */
 139 static CORE_ADDR td_create_bp_addr;
 140
 141 /* Location of the thread death event breakpoint.  */
 142 static CORE_ADDR td_death_bp_addr;
 143
 144 /* Prototypes for local functions.  */
 145 static void thread_db_find_new_threads (void);
 146 static void attach_thread (ptid_t ptid, const td_thrhandle_t *th_p,
 147                            const td_thrinfo_t *ti_p);
 148 static void detach_thread (ptid_t ptid);
 149 \f
 150
 151 /* Use "struct private_thread_info" to cache thread state.  This is
 152    a substantial optimization.  */
 153
 154 struct private_thread_info
 155 {
 156   /* Flag set when we see a TD_DEATH event for this thread.  */
 157   unsigned int dying:1;
 158
 159   /* Cached thread state.  */
 160   td_thrhandle_t th;
 161   thread_t tid;
 162 };
 163 \f
 164
 165 static char *
 166 thread_db_err_str (td_err_e err)
 167 {
 168   static char buf[64];
 169
 170   switch (err)
 171     {
 172     case TD_OK:
 173       return "generic 'call succeeded'";
 174     case TD_ERR:
 175       return "generic error";
 176     case TD_NOTHR:
 177       return "no thread to satisfy query";
 178     case TD_NOSV:
 179       return "no sync handle to satisfy query";
 180     case TD_NOLWP:
 181       return "no LWP to satisfy query";
 182     case TD_BADPH:
 183       return "invalid process handle";
 184     case TD_BADTH:
 185       return "invalid thread handle";
 186     case TD_BADSH:
 187       return "invalid synchronization handle";
 188     case TD_BADTA:
 189       return "invalid thread agent";
 190     case TD_BADKEY:
 191       return "invalid key";
 192     case TD_NOMSG:
 193       return "no event message for getmsg";
 194     case TD_NOFPREGS:
 195       return "FPU register set not available";
 196     case TD_NOLIBTHREAD:
 197       return "application not linked with libthread";
 198     case TD_NOEVENT:
 199       return "requested event is not supported";
 200     case TD_NOCAPAB:
 201       return "capability not available";
 202     case TD_DBERR:
 203       return "debugger service failed";
 204     case TD_NOAPLIC:
 205       return "operation not applicable to";
 206     case TD_NOTSD:
 207       return "no thread-specific data for this thread";
 208     case TD_MALLOC:
 209       return "malloc failed";
 210     case TD_PARTIALREG:
 211       return "only part of register set was written/read";
 212     case TD_NOXREGS:
 213       return "X register set not available for this thread";
 214 #ifdef THREAD_DB_HAS_TD_NOTALLOC
 215     case TD_NOTALLOC:
 216       return "thread has not yet allocated TLS for given module";
 217 #endif
 218 #ifdef THREAD_DB_HAS_TD_VERSION
 219     case TD_VERSION:
 220       return "versions of libpthread and libthread_db do not match";
 221 #endif
 222 #ifdef THREAD_DB_HAS_TD_NOTLS
 223     case TD_NOTLS:
 224       return "there is no TLS segment in the given module";
 225 #endif
 226     default:
 227       snprintf (buf, sizeof (buf), "unknown thread_db error '%d'", err);
 228       return buf;
 229     }
 230 }
 231 \f
 232 /* Return 1 if any threads have been registered.  There may be none if
 233    the threading library is not fully initialized yet.  */
 234
 235 static int
 236 have_threads_callback (struct thread_info *thread, void *dummy)
 237 {
 238   return 1;
 239 }
 240
 241 static int
 242 have_threads (void)
 243 {
 244   return iterate_over_threads (have_threads_callback, NULL) != NULL;
 245 }
 246
 247 /* A callback function for td_ta_thr_iter, which we use to map all
 248    threads to LWPs.
 249
 250    THP is a handle to the current thread; if INFOP is not NULL, the
 251    struct thread_info associated with this thread is returned in
 252    *INFOP.
 253
 254    If the thread is a zombie, TD_THR_ZOMBIE is returned.  Otherwise,
 255    zero is returned to indicate success.  */
 256
 257 static int
 258 thread_get_info_callback (const td_thrhandle_t *thp, void *infop)
 259 {
 260   td_thrinfo_t ti;
 261   td_err_e err;
 262   struct thread_info *thread_info;
 263   ptid_t thread_ptid;
 264
 265   err = td_thr_get_info_p (thp, &ti);
 266   if (err != TD_OK)
 267     error (_("thread_get_info_callback: cannot get thread info: %s"),
 268            thread_db_err_str (err));
 269
 270   /* Fill the cache.  */
 271   thread_ptid = ptid_build (GET_PID (inferior_ptid), ti.ti_lid, 0);
 272   thread_info = find_thread_pid (thread_ptid);
 273
 274   /* In the case of a zombie thread, don't continue.  We don't want to
 275      attach to it thinking it is a new thread.  */
 276   if (ti.ti_state == TD_THR_UNKNOWN || ti.ti_state == TD_THR_ZOMBIE)
 277     {
 278       if (infop != NULL)
 279         *(struct thread_info **) infop = thread_info;
 280       return TD_THR_ZOMBIE;
 281     }
 282
 283   if (thread_info == NULL)
 284     {
 285       /* New thread.  Attach to it now (why wait?).  */
 286       attach_thread (thread_ptid, thp, &ti);
 287       thread_info = find_thread_pid (thread_ptid);
 288       gdb_assert (thread_info != NULL);
 289     }
 290
 291   if (infop != NULL)
 292     *(struct thread_info **) infop = thread_info;
 293
 294   return 0;
 295 }
 296 \f
 297 /* Convert between user-level thread ids and LWP ids.  */
 298
 299 static ptid_t
 300 thread_from_lwp (ptid_t ptid)
 301 {
 302   td_thrhandle_t th;
 303   td_err_e err;
 304   struct thread_info *thread_info;
 305   ptid_t thread_ptid;
 306
 307   /* This ptid comes from linux-nat.c, which should always fill in the
 308      LWP.  */
 309   gdb_assert (GET_LWP (ptid) != 0);
 310
 311   err = td_ta_map_lwp2thr_p (thread_agent, GET_LWP (ptid), &th);
 312   if (err != TD_OK)
 313     error (_("Cannot find user-level thread for LWP %ld: %s"),
 314            GET_LWP (ptid), thread_db_err_str (err));
 315
 316   thread_info = NULL;
 317
 318   /* Fetch the thread info.  If we get back TD_THR_ZOMBIE, then the
 319      event thread has already died.  If another gdb interface has called
 320      thread_alive() previously, the thread won't be found on the thread list
 321      anymore.  In that case, we don't want to process this ptid anymore
 322      to avoid the possibility of later treating it as a newly
 323      discovered thread id that we should add to the list.  Thus,
 324      we return a -1 ptid which is also how the thread list marks a
 325      dead thread.  */
 326   if (thread_get_info_callback (&th, &thread_info) == TD_THR_ZOMBIE
 327       && thread_info == NULL)
 328     return pid_to_ptid (-1);
 329
 330   gdb_assert (ptid_get_tid (ptid) == 0);
 331   return ptid;
 332 }
 333 \f
 334
 335 void
 336 thread_db_init (struct target_ops *target)
 337 {
 338   target_beneath = target;
 339 }
 340
 341 static void *
 342 verbose_dlsym (void *handle, const char *name)
 343 {
 344   void *sym = dlsym (handle, name);
 345   if (sym == NULL)
 346     warning (_("Symbol \"%s\" not found in libthread_db: %s"), name, dlerror ());
 347   return sym;
 348 }
 349
 350 static int
 351 thread_db_load (void)
 352 {
 353   void *handle;
 354   td_err_e err;
 355
 356   handle = dlopen (LIBTHREAD_DB_SO, RTLD_NOW);
 357   if (handle == NULL)
 358     {
 359       fprintf_filtered (gdb_stderr, "\n\ndlopen failed on '%s' - %s\n",
 360                         LIBTHREAD_DB_SO, dlerror ());
 361       fprintf_filtered (gdb_stderr,
 362                         "GDB will not be able to debug pthreads.\n\n");
 363       return 0;
 364     }
 365
 366   /* Initialize pointers to the dynamic library functions we will use.
 367      Essential functions first.  */
 368
 369   td_init_p = verbose_dlsym (handle, "td_init");
 370   if (td_init_p == NULL)
 371     return 0;
 372
 373   td_ta_new_p = verbose_dlsym (handle, "td_ta_new");
 374   if (td_ta_new_p == NULL)
 375     return 0;
 376
 377   td_ta_map_id2thr_p = verbose_dlsym (handle, "td_ta_map_id2thr");
 378   if (td_ta_map_id2thr_p == NULL)
 379     return 0;
 380
 381   td_ta_map_lwp2thr_p = verbose_dlsym (handle, "td_ta_map_lwp2thr");
 382   if (td_ta_map_lwp2thr_p == NULL)
 383     return 0;
 384
 385   td_ta_thr_iter_p = verbose_dlsym (handle, "td_ta_thr_iter");
 386   if (td_ta_thr_iter_p == NULL)
 387     return 0;
 388
 389   td_thr_validate_p = verbose_dlsym (handle, "td_thr_validate");
 390   if (td_thr_validate_p == NULL)
 391     return 0;
 392
 393   td_thr_get_info_p = verbose_dlsym (handle, "td_thr_get_info");
 394   if (td_thr_get_info_p == NULL)
 395     return 0;
 396
 397   /* Initialize the library.  */
 398   err = td_init_p ();
 399   if (err != TD_OK)
 400     {
 401       warning (_("Cannot initialize libthread_db: %s"), thread_db_err_str (err));
 402       return 0;
 403     }
 404
 405   /* These are not essential.  */
 406   td_ta_event_addr_p = dlsym (handle, "td_ta_event_addr");
 407   td_ta_set_event_p = dlsym (handle, "td_ta_set_event");
 408   td_ta_event_getmsg_p = dlsym (handle, "td_ta_event_getmsg");
 409   td_thr_event_enable_p = dlsym (handle, "td_thr_event_enable");
 410   td_thr_tls_get_addr_p = dlsym (handle, "td_thr_tls_get_addr");
 411
 412   return 1;
 413 }
 414
 415 static td_err_e
 416 enable_thread_event (td_thragent_t *thread_agent, int event, CORE_ADDR *bp)
 417 {
 418   td_notify_t notify;
 419   td_err_e err;
 420
 421   /* Get the breakpoint address for thread EVENT.  */
 422   err = td_ta_event_addr_p (thread_agent, event, &notify);
 423   if (err != TD_OK)
 424     return err;
 425
 426   /* Set up the breakpoint.  */
 427   gdb_assert (exec_bfd);
 428   (*bp) = (gdbarch_convert_from_func_ptr_addr
 429            (current_gdbarch,
 430             /* Do proper sign extension for the target.  */
 431             (bfd_get_sign_extend_vma (exec_bfd) > 0
 432              ? (CORE_ADDR) (intptr_t) notify.u.bptaddr
 433              : (CORE_ADDR) (uintptr_t) notify.u.bptaddr),
 434             &current_target));
 435   create_thread_event_breakpoint ((*bp));
 436
 437   return TD_OK;
 438 }
 439
 440 static void
 441 enable_thread_event_reporting (void)
 442 {
 443   td_thr_events_t events;
 444   td_notify_t notify;
 445   td_err_e err;
 446 #ifdef HAVE_GNU_LIBC_VERSION_H
 447   const char *libc_version;
 448   int libc_major, libc_minor;
 449 #endif
 450
 451   /* We cannot use the thread event reporting facility if these
 452      functions aren't available.  */
 453   if (td_ta_event_addr_p == NULL || td_ta_set_event_p == NULL
 454       || td_ta_event_getmsg_p == NULL || td_thr_event_enable_p == NULL)
 455     return;
 456
 457   /* Set the process wide mask saying which events we're interested in.  */
 458   td_event_emptyset (&events);
 459   td_event_addset (&events, TD_CREATE);
 460
 461 #ifdef HAVE_GNU_LIBC_VERSION_H
 462   /* The event reporting facility is broken for TD_DEATH events in
 463      glibc 2.1.3, so don't enable it if we have glibc but a lower
 464      version.  */
 465   libc_version = gnu_get_libc_version ();
 466   if (sscanf (libc_version, "%d.%d", &libc_major, &libc_minor) == 2
 467       && (libc_major > 2 || (libc_major == 2 && libc_minor > 1)))
 468 #endif
 469     td_event_addset (&events, TD_DEATH);
 470
 471   err = td_ta_set_event_p (thread_agent, &events);
 472   if (err != TD_OK)
 473     {
 474       warning (_("Unable to set global thread event mask: %s"),
 475                thread_db_err_str (err));
 476       return;
 477     }
 478
 479   /* Delete previous thread event breakpoints, if any.  */
 480   remove_thread_event_breakpoints ();
 481   td_create_bp_addr = 0;
 482   td_death_bp_addr = 0;
 483
 484   /* Set up the thread creation event.  */
 485   err = enable_thread_event (thread_agent, TD_CREATE, &td_create_bp_addr);
 486   if (err != TD_OK)
 487     {
 488       warning (_("Unable to get location for thread creation breakpoint: %s"),
 489                thread_db_err_str (err));
 490       return;
 491     }
 492
 493   /* Set up the thread death event.  */
 494   err = enable_thread_event (thread_agent, TD_DEATH, &td_death_bp_addr);
 495   if (err != TD_OK)
 496     {
 497       warning (_("Unable to get location for thread death breakpoint: %s"),
 498                thread_db_err_str (err));
 499       return;
 500     }
 501 }
 502
 503 static void
 504 disable_thread_event_reporting (void)
 505 {
 506   td_thr_events_t events;
 507
 508   /* Set the process wide mask saying we aren't interested in any
 509      events anymore.  */
 510   td_event_emptyset (&events);
 511   td_ta_set_event_p (thread_agent, &events);
 512
 513   /* Delete thread event breakpoints, if any.  */
 514   remove_thread_event_breakpoints ();
 515   td_create_bp_addr = 0;
 516   td_death_bp_addr = 0;
 517 }
 518
 519 static void
 520 check_thread_signals (void)
 521 {
 522 #ifdef GET_THREAD_SIGNALS
 523   if (!thread_signals)
 524     {
 525       sigset_t mask;
 526       int i;
 527
 528       GET_THREAD_SIGNALS (&mask);
 529       sigemptyset (&thread_stop_set);
 530       sigemptyset (&thread_print_set);
 531
 532       for (i = 1; i < NSIG; i++)
 533         {
 534           if (sigismember (&mask, i))
 535             {
 536               if (signal_stop_update (target_signal_from_host (i), 0))
 537                 sigaddset (&thread_stop_set, i);
 538               if (signal_print_update (target_signal_from_host (i), 0))
 539                 sigaddset (&thread_print_set, i);
 540               thread_signals = 1;
 541             }
 542         }
 543     }
 544 #endif
 545 }
 546
 547 /* Check whether thread_db is usable.  This function is called when
 548    an inferior is created (or otherwise acquired, e.g. attached to)
 549    and when new shared libraries are loaded into a running process.  */
 550
 551 void
 552 check_for_thread_db (void)
 553 {
 554   td_err_e err;
 555   static int already_loaded;
 556
 557   /* Do nothing if we couldn't load libthread_db.so.1.  */
 558   if (td_ta_new_p == NULL)
 559     return;
 560
 561   /* First time through, report that libthread_db was successfuly
 562      loaded.  Can't print this in in thread_db_load as, at that stage,
 563      the interpreter and it's console haven't started.  */
 564
 565   if (!already_loaded)
 566     {
 567       Dl_info info;
 568       const char *library = NULL;
 569       if (dladdr ((*td_ta_new_p), &info) != 0)
 570         library = info.dli_fname;
 571
 572       /* Try dlinfo?  */
 573
 574       if (library == NULL)
 575         /* Paranoid - don't let a NULL path slip through.  */
 576         library = LIBTHREAD_DB_SO;
 577
 578       if (info_verbose)
 579         printf_unfiltered (_("Using host libthread_db library \"%s\".\n"),
 580                            library);
 581       already_loaded = 1;
 582     }
 583
 584   if (using_thread_db)
 585     /* Nothing to do.  The thread library was already detected and the
 586        target vector was already activated.  */
 587     return;
 588
 589   /* Don't attempt to use thread_db on targets which can not run
 590      (executables not running yet, core files) for now.  */
 591   if (!target_has_execution)
 592     return;
 593
 594   /* Don't attempt to use thread_db for remote targets.  */
 595   if (!target_can_run (&current_target))
 596     return;
 597
 598   /* Initialize the structure that identifies the child process.  */
 599   proc_handle.pid = GET_PID (inferior_ptid);
 600
 601   /* Now attempt to open a connection to the thread library.  */
 602   err = td_ta_new_p (&proc_handle, &thread_agent);
 603   switch (err)
 604     {
 605     case TD_NOLIBTHREAD:
 606       /* No thread library was detected.  */
 607       break;
 608
 609     case TD_OK:
 610       printf_unfiltered (_("[Thread debugging using libthread_db enabled]\n"));
 611
 612       /* The thread library was detected.  Activate the thread_db target.  */
 613       push_target (&thread_db_ops);
 614       using_thread_db = 1;
 615
 616       enable_thread_event_reporting ();
 617       thread_db_find_new_threads ();
 618       break;
 619
 620     default:
 621       warning (_("Cannot initialize thread debugging library: %s"),
 622                thread_db_err_str (err));
 623       break;
 624     }
 625 }
 626
 627 static void
 628 thread_db_new_objfile (struct objfile *objfile)
 629 {
 630   if (objfile != NULL)
 631     check_for_thread_db ();
 632 }
 633
 634 /* Attach to a new thread.  This function is called when we receive a
 635    TD_CREATE event or when we iterate over all threads and find one
 636    that wasn't already in our list.  */
 637
 638 static void
 639 attach_thread (ptid_t ptid, const td_thrhandle_t *th_p,
 640                const td_thrinfo_t *ti_p)
 641 {
 642   struct private_thread_info *private;
 643   struct thread_info *tp = NULL;
 644   td_err_e err;
 645
 646   /* If we're being called after a TD_CREATE event, we may already
 647      know about this thread.  There are two ways this can happen.  We
 648      may have iterated over all threads between the thread creation
 649      and the TD_CREATE event, for instance when the user has issued
 650      the `info threads' command before the SIGTRAP for hitting the
 651      thread creation breakpoint was reported.  Alternatively, the
 652      thread may have exited and a new one been created with the same
 653      thread ID.  In the first case we don't need to do anything; in
 654      the second case we should discard information about the dead
 655      thread and attach to the new one.  */
 656   if (in_thread_list (ptid))
 657     {
 658       tp = find_thread_pid (ptid);
 659       gdb_assert (tp != NULL);
 660
 661       /* If tp->private is NULL, then GDB is already attached to this
 662          thread, but we do not know anything about it.  We can learn
 663          about it here.  This can only happen if we have some other
 664          way besides libthread_db to notice new threads (i.e.
 665          PTRACE_EVENT_CLONE); assume the same mechanism notices thread
 666          exit, so this can not be a stale thread recreated with the
 667          same ID.  */
 668       if (tp->private != NULL)
 669         {
 670           if (!tp->private->dying)
 671             return;
 672
 673           delete_thread (ptid);
 674           tp = NULL;
 675         }
 676     }
 677
 678   check_thread_signals ();
 679
 680   if (ti_p->ti_state == TD_THR_UNKNOWN || ti_p->ti_state == TD_THR_ZOMBIE)
 681     return;                     /* A zombie thread -- do not attach.  */
 682
 683   /* Under GNU/Linux, we have to attach to each and every thread.  */
 684   if (tp == NULL
 685       && lin_lwp_attach_lwp (BUILD_LWP (ti_p->ti_lid, GET_PID (ptid))) < 0)
 686     return;
 687
 688   /* Construct the thread's private data.  */
 689   private = xmalloc (sizeof (struct private_thread_info));
 690   memset (private, 0, sizeof (struct private_thread_info));
 691
 692   /* A thread ID of zero may mean the thread library has not initialized
 693      yet.  But we shouldn't even get here if that's the case.  FIXME:
 694      if we change GDB to always have at least one thread in the thread
 695      list this will have to go somewhere else; maybe private == NULL
 696      until the thread_db target claims it.  */
 697   gdb_assert (ti_p->ti_tid != 0);
 698   private->th = *th_p;
 699   private->tid = ti_p->ti_tid;
 700
 701   /* Add the thread to GDB's thread list.  */
 702   if (tp == NULL)
 703     tp = add_thread_with_info (ptid, private);
 704   else
 705     tp->private = private;
 706
 707   /* Enable thread event reporting for this thread.  */
 708   err = td_thr_event_enable_p (th_p, 1);
 709   if (err != TD_OK)
 710     error (_("Cannot enable thread event reporting for %s: %s"),
 711            target_pid_to_str (ptid), thread_db_err_str (err));
 712 }
 713
 714 static void
 715 detach_thread (ptid_t ptid)
 716 {
 717   struct thread_info *thread_info;
 718
 719   /* Don't delete the thread now, because it still reports as active
 720      until it has executed a few instructions after the event
 721      breakpoint - if we deleted it now, "info threads" would cause us
 722      to re-attach to it.  Just mark it as having had a TD_DEATH
 723      event.  This means that we won't delete it from our thread list
 724      until we notice that it's dead (via prune_threads), or until
 725      something re-uses its thread ID.  We'll report the thread exit
 726      when the underlying LWP dies.  */
 727   thread_info = find_thread_pid (ptid);
 728   gdb_assert (thread_info != NULL && thread_info->private != NULL);
 729   thread_info->private->dying = 1;
 730 }
 731
 732 static void
 733 thread_db_detach (char *args, int from_tty)
 734 {
 735   disable_thread_event_reporting ();
 736
 737   target_beneath->to_detach (args, from_tty);
 738
 739   /* Should this be done by detach_command?  */
 740   target_mourn_inferior ();
 741 }
 742
 743 /* Check if PID is currently stopped at the location of a thread event
 744    breakpoint location.  If it is, read the event message and act upon
 745    the event.  */
 746
 747 static void
 748 check_event (ptid_t ptid)
 749 {
 750   td_event_msg_t msg;
 751   td_thrinfo_t ti;
 752   td_err_e err;
 753   CORE_ADDR stop_pc;
 754   int loop = 0;
 755
 756   /* Bail out early if we're not at a thread event breakpoint.  */
 757   stop_pc = read_pc_pid (ptid) - gdbarch_decr_pc_after_break (current_gdbarch);
 758   if (stop_pc != td_create_bp_addr && stop_pc != td_death_bp_addr)
 759     return;
 760
 761   /* If we are at a create breakpoint, we do not know what new lwp
 762      was created and cannot specifically locate the event message for it.
 763      We have to call td_ta_event_getmsg() to get
 764      the latest message.  Since we have no way of correlating whether
 765      the event message we get back corresponds to our breakpoint, we must
 766      loop and read all event messages, processing them appropriately.
 767      This guarantees we will process the correct message before continuing
 768      from the breakpoint.
 769
 770      Currently, death events are not enabled.  If they are enabled,
 771      the death event can use the td_thr_event_getmsg() interface to
 772      get the message specifically for that lwp and avoid looping
 773      below.  */
 774
 775   loop = 1;
 776
 777   do
 778     {
 779       err = td_ta_event_getmsg_p (thread_agent, &msg);
 780       if (err != TD_OK)
 781         {
 782           if (err == TD_NOMSG)
 783             return;
 784
 785           error (_("Cannot get thread event message: %s"),
 786                  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 (_("Cannot get thread info: %s"), thread_db_err_str (err));
 792
 793       ptid = ptid_build (GET_PID (ptid), ti.ti_lid, 0);
 794
 795       switch (msg.event)
 796         {
 797         case TD_CREATE:
 798           /* Call attach_thread whether or not we already know about a
 799              thread with this thread ID.  */
 800           attach_thread (ptid, msg.th_p, &ti);
 801
 802           break;
 803
 804         case TD_DEATH:
 805
 806           if (!in_thread_list (ptid))
 807             error (_("Spurious thread death event."));
 808
 809           detach_thread (ptid);
 810
 811           break;
 812
 813         default:
 814           error (_("Spurious thread event."));
 815         }
 816     }
 817   while (loop);
 818 }
 819
 820 static ptid_t
 821 thread_db_wait (ptid_t ptid, struct target_waitstatus *ourstatus)
 822 {
 823   extern ptid_t trap_ptid;
 824
 825   ptid = target_beneath->to_wait (ptid, ourstatus);
 826
 827   if (ourstatus->kind == TARGET_WAITKIND_IGNORE)
 828     return ptid;
 829
 830   if (ourstatus->kind == TARGET_WAITKIND_EXITED
 831     || ourstatus->kind == TARGET_WAITKIND_SIGNALLED)
 832     return pid_to_ptid (-1);
 833
 834   if (ourstatus->kind == TARGET_WAITKIND_EXECD)
 835     {
 836       remove_thread_event_breakpoints ();
 837       unpush_target (&thread_db_ops);
 838       using_thread_db = 0;
 839
 840       return pid_to_ptid (GET_PID (ptid));
 841     }
 842
 843   /* If we do not know about the main thread yet, this would be a good time to
 844      find it.  */
 845   if (ourstatus->kind == TARGET_WAITKIND_STOPPED && !have_threads ())
 846     thread_db_find_new_threads ();
 847
 848   if (ourstatus->kind == TARGET_WAITKIND_STOPPED
 849       && ourstatus->value.sig == TARGET_SIGNAL_TRAP)
 850     /* Check for a thread event.  */
 851     check_event (ptid);
 852
 853   if (have_threads ())
 854     {
 855       /* Change ptids back into the higher level PID + TID format.  If
 856          the thread is dead and no longer on the thread list, we will
 857          get back a dead ptid.  This can occur if the thread death
 858          event gets postponed by other simultaneous events.  In such a
 859          case, we want to just ignore the event and continue on.  */
 860
 861       if (!ptid_equal (trap_ptid, null_ptid))
 862         trap_ptid = thread_from_lwp (trap_ptid);
 863
 864       ptid = thread_from_lwp (ptid);
 865       if (GET_PID (ptid) == -1)
 866         ourstatus->kind = TARGET_WAITKIND_SPURIOUS;
 867     }
 868
 869   return ptid;
 870 }
 871
 872 static void
 873 thread_db_mourn_inferior (void)
 874 {
 875   /* Forget about the child's process ID.  We shouldn't need it
 876      anymore.  */
 877   proc_handle.pid = 0;
 878
 879   target_beneath->to_mourn_inferior ();
 880
 881   /* Delete the old thread event breakpoints.  Do this after mourning
 882      the inferior, so that we don't try to uninsert them.  */
 883   remove_thread_event_breakpoints ();
 884
 885   /* Detach thread_db target ops.  */
 886   unpush_target (&thread_db_ops);
 887   using_thread_db = 0;
 888 }
 889
 890 static int
 891 thread_db_can_async_p (void)
 892 {
 893   return target_beneath->to_can_async_p ();
 894 }
 895
 896 static int
 897 thread_db_is_async_p (void)
 898 {
 899   return target_beneath->to_is_async_p ();
 900 }
 901
 902 static void
 903 thread_db_async (void (*callback) (enum inferior_event_type event_type,
 904                                    void *context), void *context)
 905 {
 906   return target_beneath->to_async (callback, context);
 907 }
 908
 909 static int
 910 thread_db_async_mask (int mask)
 911 {
 912   return target_beneath->to_async_mask (mask);
 913 }
 914
 915 static int
 916 find_new_threads_callback (const td_thrhandle_t *th_p, void *data)
 917 {
 918   td_thrinfo_t ti;
 919   td_err_e err;
 920   ptid_t ptid;
 921   struct thread_info *tp;
 922
 923   err = td_thr_get_info_p (th_p, &ti);
 924   if (err != TD_OK)
 925     error (_("find_new_threads_callback: cannot get thread info: %s"),
 926            thread_db_err_str (err));
 927
 928   if (ti.ti_state == TD_THR_UNKNOWN || ti.ti_state == TD_THR_ZOMBIE)
 929     return 0;                   /* A zombie -- ignore.  */
 930
 931   ptid = ptid_build (GET_PID (inferior_ptid), ti.ti_lid, 0);
 932
 933   if (ti.ti_tid == 0)
 934     {
 935       /* A thread ID of zero means that this is the main thread, but
 936          glibc has not yet initialized thread-local storage and the
 937          pthread library.  We do not know what the thread's TID will
 938          be yet.  Just enable event reporting and otherwise ignore
 939          it.  */
 940
 941       err = td_thr_event_enable_p (th_p, 1);
 942       if (err != TD_OK)
 943         error (_("Cannot enable thread event reporting for %s: %s"),
 944                target_pid_to_str (ptid), thread_db_err_str (err));
 945
 946       return 0;
 947     }
 948
 949   tp = find_thread_pid (ptid);
 950   if (tp == NULL || tp->private == NULL)
 951     attach_thread (ptid, th_p, &ti);
 952
 953   return 0;
 954 }
 955
 956 static void
 957 thread_db_find_new_threads (void)
 958 {
 959   td_err_e err;
 960
 961   /* Iterate over all user-space threads to discover new threads.  */
 962   err = td_ta_thr_iter_p (thread_agent, find_new_threads_callback, NULL,
 963                           TD_THR_ANY_STATE, TD_THR_LOWEST_PRIORITY,
 964                           TD_SIGNO_MASK, TD_THR_ANY_USER_FLAGS);
 965   if (err != TD_OK)
 966     error (_("Cannot find new threads: %s"), thread_db_err_str (err));
 967 }
 968
 969 static char *
 970 thread_db_pid_to_str (ptid_t ptid)
 971 {
 972   struct thread_info *thread_info = find_thread_pid (ptid);
 973
 974   if (thread_info != NULL && thread_info->private != NULL)
 975     {
 976       static char buf[64];
 977       thread_t tid;
 978
 979       tid = thread_info->private->tid;
 980       thread_info = find_thread_pid (ptid);
 981       snprintf (buf, sizeof (buf), "Thread 0x%lx (LWP %ld)",
 982                 tid, GET_LWP (ptid));
 983
 984       return buf;
 985     }
 986
 987   if (target_beneath->to_pid_to_str (ptid))
 988     return target_beneath->to_pid_to_str (ptid);
 989
 990   return normal_pid_to_str (ptid);
 991 }
 992
 993 /* Return a string describing the state of the thread specified by
 994    INFO.  */
 995
 996 static char *
 997 thread_db_extra_thread_info (struct thread_info *info)
 998 {
 999   if (info->private == NULL)
1000     return NULL;
1001
1002   if (info->private->dying)
1003     return "Exiting";
1004
1005   return NULL;
1006 }
1007
1008 /* Get the address of the thread local variable in load module LM which
1009    is stored at OFFSET within the thread local storage for thread PTID.  */
1010
1011 static CORE_ADDR
1012 thread_db_get_thread_local_address (ptid_t ptid,
1013                                     CORE_ADDR lm,
1014                                     CORE_ADDR offset)
1015 {
1016   struct thread_info *thread_info;
1017
1018   /* If we have not discovered any threads yet, check now.  */
1019   if (!have_threads ())
1020     thread_db_find_new_threads ();
1021
1022   /* Find the matching thread.  */
1023   thread_info = find_thread_pid (ptid);
1024
1025   if (thread_info != NULL && thread_info->private != NULL)
1026     {
1027       td_err_e err;
1028       void *address;
1029
1030       /* glibc doesn't provide the needed interface.  */
1031       if (!td_thr_tls_get_addr_p)
1032         throw_error (TLS_NO_LIBRARY_SUPPORT_ERROR,
1033                      _("No TLS library support"));
1034
1035       /* Caller should have verified that lm != 0.  */
1036       gdb_assert (lm != 0);
1037
1038       /* Finally, get the address of the variable.  */
1039       err = td_thr_tls_get_addr_p (&thread_info->private->th,
1040                                    (void *)(size_t) lm,
1041                                    offset, &address);
1042
1043 #ifdef THREAD_DB_HAS_TD_NOTALLOC
1044       /* The memory hasn't been allocated, yet.  */
1045       if (err == TD_NOTALLOC)
1046           /* Now, if libthread_db provided the initialization image's
1047              address, we *could* try to build a non-lvalue value from
1048              the initialization image.  */
1049         throw_error (TLS_NOT_ALLOCATED_YET_ERROR,
1050                      _("TLS not allocated yet"));
1051 #endif
1052
1053       /* Something else went wrong.  */
1054       if (err != TD_OK)
1055         throw_error (TLS_GENERIC_ERROR,
1056                      (("%s")), thread_db_err_str (err));
1057
1058       /* Cast assuming host == target.  Joy.  */
1059       /* Do proper sign extension for the target.  */
1060       gdb_assert (exec_bfd);
1061       return (bfd_get_sign_extend_vma (exec_bfd) > 0
1062               ? (CORE_ADDR) (intptr_t) address
1063               : (CORE_ADDR) (uintptr_t) address);
1064     }
1065
1066   if (target_beneath->to_get_thread_local_address)
1067     return target_beneath->to_get_thread_local_address (ptid, lm, offset);
1068   else
1069     throw_error (TLS_GENERIC_ERROR,
1070                  _("TLS not supported on this target"));
1071 }
1072
1073 static void
1074 init_thread_db_ops (void)
1075 {
1076   thread_db_ops.to_shortname = "multi-thread";
1077   thread_db_ops.to_longname = "multi-threaded child process.";
1078   thread_db_ops.to_doc = "Threads and pthreads support.";
1079   thread_db_ops.to_detach = thread_db_detach;
1080   thread_db_ops.to_wait = thread_db_wait;
1081   thread_db_ops.to_mourn_inferior = thread_db_mourn_inferior;
1082   thread_db_ops.to_find_new_threads = thread_db_find_new_threads;
1083   thread_db_ops.to_pid_to_str = thread_db_pid_to_str;
1084   thread_db_ops.to_stratum = thread_stratum;
1085   thread_db_ops.to_has_thread_control = tc_schedlock;
1086   thread_db_ops.to_get_thread_local_address
1087     = thread_db_get_thread_local_address;
1088   thread_db_ops.to_extra_thread_info = thread_db_extra_thread_info;
1089   thread_db_ops.to_can_async_p = thread_db_can_async_p;
1090   thread_db_ops.to_is_async_p = thread_db_is_async_p;
1091   thread_db_ops.to_async = thread_db_async;
1092   thread_db_ops.to_async_mask = thread_db_async_mask;
1093   thread_db_ops.to_magic = OPS_MAGIC;
1094 }
1095
1096 void
1097 _initialize_thread_db (void)
1098 {
1099   /* Only initialize the module if we can load libthread_db.  */
1100   if (thread_db_load ())
1101     {
1102       init_thread_db_ops ();
1103       add_target (&thread_db_ops);
1104
1105       /* Add ourselves to objfile event chain.  */
1106       observer_attach_new_objfile (thread_db_new_objfile);
1107     }
1108 }