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