2011-09-02 Pedro Alves <pedro@codesourcery.com>
[platform/upstream/binutils.git] / 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, 2009,
4    2010, 2011 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 "command.h"
30 #include "exceptions.h"
31 #include "gdbcmd.h"
32 #include "gdbthread.h"
33 #include "inferior.h"
34 #include "symfile.h"
35 #include "objfiles.h"
36 #include "target.h"
37 #include "regcache.h"
38 #include "solib.h"
39 #include "solib-svr4.h"
40 #include "gdbcore.h"
41 #include "observer.h"
42 #include "linux-nat.h"
43 #include "linux-procfs.h"
44
45 #include <signal.h>
46
47 #ifdef HAVE_GNU_LIBC_VERSION_H
48 #include <gnu/libc-version.h>
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 static char *libthread_db_search_path;
78
79 static void
80 set_libthread_db_search_path (char *ignored, int from_tty,
81                               struct cmd_list_element *c)
82 {
83   if (*libthread_db_search_path == '\0')
84     {
85       xfree (libthread_db_search_path);
86       libthread_db_search_path = xstrdup (LIBTHREAD_DB_SEARCH_PATH);
87     }
88 }
89
90 /* If non-zero, print details of libthread_db processing.  */
91
92 static int libthread_db_debug;
93
94 static void
95 show_libthread_db_debug (struct ui_file *file, int from_tty,
96                          struct cmd_list_element *c, const char *value)
97 {
98   fprintf_filtered (file, _("libthread-db debugging is %s.\n"), value);
99 }
100
101 /* If we're running on GNU/Linux, we must explicitly attach to any new
102    threads.  */
103
104 /* This module's target vector.  */
105 static struct target_ops thread_db_ops;
106
107 /* Non-zero if we have determined the signals used by the threads
108    library.  */
109 static int thread_signals;
110 static sigset_t thread_stop_set;
111 static sigset_t thread_print_set;
112
113 struct thread_db_info
114 {
115   struct thread_db_info *next;
116
117   /* Process id this object refers to.  */
118   int pid;
119
120   /* Handle from dlopen for libthread_db.so.  */
121   void *handle;
122
123   /* Structure that identifies the child process for the
124      <proc_service.h> interface.  */
125   struct ps_prochandle proc_handle;
126
127   /* Connection to the libthread_db library.  */
128   td_thragent_t *thread_agent;
129
130   /* True if we need to apply the workaround for glibc/BZ5983.  When
131      we catch a PTRACE_O_TRACEFORK, and go query the child's thread
132      list, nptl_db returns the parent's threads in addition to the new
133      (single) child thread.  If this flag is set, we do extra work to
134      be able to ignore such stale entries.  */
135   int need_stale_parent_threads_check;
136
137   /* Location of the thread creation event breakpoint.  The code at
138      this location in the child process will be called by the pthread
139      library whenever a new thread is created.  By setting a special
140      breakpoint at this location, GDB can detect when a new thread is
141      created.  We obtain this location via the td_ta_event_addr
142      call.  */
143   CORE_ADDR td_create_bp_addr;
144
145   /* Location of the thread death event breakpoint.  */
146   CORE_ADDR td_death_bp_addr;
147
148   /* Pointers to the libthread_db functions.  */
149
150   td_err_e (*td_init_p) (void);
151
152   td_err_e (*td_ta_new_p) (struct ps_prochandle * ps,
153                                 td_thragent_t **ta);
154   td_err_e (*td_ta_map_id2thr_p) (const td_thragent_t *ta, thread_t pt,
155                                   td_thrhandle_t *__th);
156   td_err_e (*td_ta_map_lwp2thr_p) (const td_thragent_t *ta,
157                                    lwpid_t lwpid, td_thrhandle_t *th);
158   td_err_e (*td_ta_thr_iter_p) (const td_thragent_t *ta,
159                                 td_thr_iter_f *callback, void *cbdata_p,
160                                 td_thr_state_e state, int ti_pri,
161                                 sigset_t *ti_sigmask_p,
162                                 unsigned int ti_user_flags);
163   td_err_e (*td_ta_event_addr_p) (const td_thragent_t *ta,
164                                   td_event_e event, td_notify_t *ptr);
165   td_err_e (*td_ta_set_event_p) (const td_thragent_t *ta,
166                                  td_thr_events_t *event);
167   td_err_e (*td_ta_clear_event_p) (const td_thragent_t *ta,
168                                    td_thr_events_t *event);
169   td_err_e (*td_ta_event_getmsg_p) (const td_thragent_t *ta,
170                                     td_event_msg_t *msg);
171
172   td_err_e (*td_thr_validate_p) (const td_thrhandle_t *th);
173   td_err_e (*td_thr_get_info_p) (const td_thrhandle_t *th,
174                                  td_thrinfo_t *infop);
175   td_err_e (*td_thr_event_enable_p) (const td_thrhandle_t *th,
176                                      int event);
177
178   td_err_e (*td_thr_tls_get_addr_p) (const td_thrhandle_t *th,
179                                      psaddr_t map_address,
180                                      size_t offset, psaddr_t *address);
181 };
182
183 /* List of known processes using thread_db, and the required
184    bookkeeping.  */
185 struct thread_db_info *thread_db_list;
186
187 static void thread_db_find_new_threads_1 (ptid_t ptid);
188 static void thread_db_find_new_threads_2 (ptid_t ptid, int until_no_new);
189
190 /* Add the current inferior to the list of processes using libpthread.
191    Return a pointer to the newly allocated object that was added to
192    THREAD_DB_LIST.  HANDLE is the handle returned by dlopen'ing
193    LIBTHREAD_DB_SO.  */
194
195 static struct thread_db_info *
196 add_thread_db_info (void *handle)
197 {
198   struct thread_db_info *info;
199
200   info = xcalloc (1, sizeof (*info));
201   info->pid = ptid_get_pid (inferior_ptid);
202   info->handle = handle;
203
204   /* The workaround works by reading from /proc/pid/status, so it is
205      disabled for core files.  */
206   if (target_has_execution)
207     info->need_stale_parent_threads_check = 1;
208
209   info->next = thread_db_list;
210   thread_db_list = info;
211
212   return info;
213 }
214
215 /* Return the thread_db_info object representing the bookkeeping
216    related to process PID, if any; NULL otherwise.  */
217
218 static struct thread_db_info *
219 get_thread_db_info (int pid)
220 {
221   struct thread_db_info *info;
222
223   for (info = thread_db_list; info; info = info->next)
224     if (pid == info->pid)
225       return info;
226
227   return NULL;
228 }
229
230 /* When PID has exited or has been detached, we no longer want to keep
231    track of it as using libpthread.  Call this function to discard
232    thread_db related info related to PID.  Note that this closes
233    LIBTHREAD_DB_SO's dlopen'ed handle.  */
234
235 static void
236 delete_thread_db_info (int pid)
237 {
238   struct thread_db_info *info, *info_prev;
239
240   info_prev = NULL;
241
242   for (info = thread_db_list; info; info_prev = info, info = info->next)
243     if (pid == info->pid)
244       break;
245
246   if (info == NULL)
247     return;
248
249   if (info->handle != NULL)
250     dlclose (info->handle);
251
252   if (info_prev)
253     info_prev->next = info->next;
254   else
255     thread_db_list = info->next;
256
257   xfree (info);
258 }
259
260 /* Prototypes for local functions.  */
261 static int attach_thread (ptid_t ptid, const td_thrhandle_t *th_p,
262                           const td_thrinfo_t *ti_p);
263 static void detach_thread (ptid_t ptid);
264 \f
265
266 /* Use "struct private_thread_info" to cache thread state.  This is
267    a substantial optimization.  */
268
269 struct private_thread_info
270 {
271   /* Flag set when we see a TD_DEATH event for this thread.  */
272   unsigned int dying:1;
273
274   /* Cached thread state.  */
275   td_thrhandle_t th;
276   thread_t tid;
277 };
278 \f
279
280 static char *
281 thread_db_err_str (td_err_e err)
282 {
283   static char buf[64];
284
285   switch (err)
286     {
287     case TD_OK:
288       return "generic 'call succeeded'";
289     case TD_ERR:
290       return "generic error";
291     case TD_NOTHR:
292       return "no thread to satisfy query";
293     case TD_NOSV:
294       return "no sync handle to satisfy query";
295     case TD_NOLWP:
296       return "no LWP to satisfy query";
297     case TD_BADPH:
298       return "invalid process handle";
299     case TD_BADTH:
300       return "invalid thread handle";
301     case TD_BADSH:
302       return "invalid synchronization handle";
303     case TD_BADTA:
304       return "invalid thread agent";
305     case TD_BADKEY:
306       return "invalid key";
307     case TD_NOMSG:
308       return "no event message for getmsg";
309     case TD_NOFPREGS:
310       return "FPU register set not available";
311     case TD_NOLIBTHREAD:
312       return "application not linked with libthread";
313     case TD_NOEVENT:
314       return "requested event is not supported";
315     case TD_NOCAPAB:
316       return "capability not available";
317     case TD_DBERR:
318       return "debugger service failed";
319     case TD_NOAPLIC:
320       return "operation not applicable to";
321     case TD_NOTSD:
322       return "no thread-specific data for this thread";
323     case TD_MALLOC:
324       return "malloc failed";
325     case TD_PARTIALREG:
326       return "only part of register set was written/read";
327     case TD_NOXREGS:
328       return "X register set not available for this thread";
329 #ifdef THREAD_DB_HAS_TD_NOTALLOC
330     case TD_NOTALLOC:
331       return "thread has not yet allocated TLS for given module";
332 #endif
333 #ifdef THREAD_DB_HAS_TD_VERSION
334     case TD_VERSION:
335       return "versions of libpthread and libthread_db do not match";
336 #endif
337 #ifdef THREAD_DB_HAS_TD_NOTLS
338     case TD_NOTLS:
339       return "there is no TLS segment in the given module";
340 #endif
341     default:
342       snprintf (buf, sizeof (buf), "unknown thread_db error '%d'", err);
343       return buf;
344     }
345 }
346 \f
347 /* Return 1 if any threads have been registered.  There may be none if
348    the threading library is not fully initialized yet.  */
349
350 static int
351 have_threads_callback (struct thread_info *thread, void *args)
352 {
353   int pid = * (int *) args;
354
355   if (ptid_get_pid (thread->ptid) != pid)
356     return 0;
357
358   return thread->private != NULL;
359 }
360
361 static int
362 have_threads (ptid_t ptid)
363 {
364   int pid = ptid_get_pid (ptid);
365
366   return iterate_over_threads (have_threads_callback, &pid) != NULL;
367 }
368
369 struct thread_get_info_inout
370 {
371   struct thread_info *thread_info;
372   struct thread_db_info *thread_db_info;
373 };
374
375 /* A callback function for td_ta_thr_iter, which we use to map all
376    threads to LWPs.
377
378    THP is a handle to the current thread; if INFOP is not NULL, the
379    struct thread_info associated with this thread is returned in
380    *INFOP.
381
382    If the thread is a zombie, TD_THR_ZOMBIE is returned.  Otherwise,
383    zero is returned to indicate success.  */
384
385 static int
386 thread_get_info_callback (const td_thrhandle_t *thp, void *argp)
387 {
388   td_thrinfo_t ti;
389   td_err_e err;
390   ptid_t thread_ptid;
391   struct thread_get_info_inout *inout;
392   struct thread_db_info *info;
393
394   inout = argp;
395   info = inout->thread_db_info;
396
397   err = info->td_thr_get_info_p (thp, &ti);
398   if (err != TD_OK)
399     error (_("thread_get_info_callback: cannot get thread info: %s"),
400            thread_db_err_str (err));
401
402   /* Fill the cache.  */
403   thread_ptid = ptid_build (info->pid, ti.ti_lid, 0);
404   inout->thread_info = find_thread_ptid (thread_ptid);
405
406   /* In the case of a zombie thread, don't continue.  We don't want to
407      attach to it thinking it is a new thread.  */
408   if (ti.ti_state == TD_THR_UNKNOWN || ti.ti_state == TD_THR_ZOMBIE)
409     return TD_THR_ZOMBIE;
410
411   if (inout->thread_info == NULL)
412     {
413       /* New thread.  Attach to it now (why wait?).  */
414       if (!have_threads (thread_ptid))
415         thread_db_find_new_threads_1 (thread_ptid);
416       else
417         attach_thread (thread_ptid, thp, &ti);
418       inout->thread_info = find_thread_ptid (thread_ptid);
419       gdb_assert (inout->thread_info != NULL);
420     }
421
422   return 0;
423 }
424 \f
425 /* Convert between user-level thread ids and LWP ids.  */
426
427 static ptid_t
428 thread_from_lwp (ptid_t ptid)
429 {
430   td_thrhandle_t th;
431   td_err_e err;
432   struct thread_db_info *info;
433   struct thread_get_info_inout io = {0};
434
435   /* Just in case td_ta_map_lwp2thr doesn't initialize it completely.  */
436   th.th_unique = 0;
437
438   /* This ptid comes from linux-nat.c, which should always fill in the
439      LWP.  */
440   gdb_assert (GET_LWP (ptid) != 0);
441
442   info = get_thread_db_info (GET_PID (ptid));
443
444   /* Access an lwp we know is stopped.  */
445   info->proc_handle.ptid = ptid;
446   err = info->td_ta_map_lwp2thr_p (info->thread_agent, GET_LWP (ptid), &th);
447   if (err != TD_OK)
448     error (_("Cannot find user-level thread for LWP %ld: %s"),
449            GET_LWP (ptid), thread_db_err_str (err));
450
451   /* Fetch the thread info.  If we get back TD_THR_ZOMBIE, then the
452      event thread has already died.  If another gdb interface has called
453      thread_alive() previously, the thread won't be found on the thread list
454      anymore.  In that case, we don't want to process this ptid anymore
455      to avoid the possibility of later treating it as a newly
456      discovered thread id that we should add to the list.  Thus,
457      we return a -1 ptid which is also how the thread list marks a
458      dead thread.  */
459   io.thread_db_info = info;
460   io.thread_info = NULL;
461   if (thread_get_info_callback (&th, &io) == TD_THR_ZOMBIE
462       && io.thread_info == NULL)
463     return minus_one_ptid;
464
465   gdb_assert (ptid_get_tid (ptid) == 0);
466   return ptid;
467 }
468 \f
469
470 /* Attach to lwp PTID, doing whatever else is required to have this
471    LWP under the debugger's control --- e.g., enabling event
472    reporting.  Returns true on success.  */
473 int
474 thread_db_attach_lwp (ptid_t ptid)
475 {
476   td_thrhandle_t th;
477   td_thrinfo_t ti;
478   td_err_e err;
479   struct thread_db_info *info;
480
481   info = get_thread_db_info (GET_PID (ptid));
482
483   if (info == NULL)
484     return 0;
485
486   /* This ptid comes from linux-nat.c, which should always fill in the
487      LWP.  */
488   gdb_assert (GET_LWP (ptid) != 0);
489
490   /* Access an lwp we know is stopped.  */
491   info->proc_handle.ptid = ptid;
492
493   /* If we have only looked at the first thread before libpthread was
494      initialized, we may not know its thread ID yet.  Make sure we do
495      before we add another thread to the list.  */
496   if (!have_threads (ptid))
497     thread_db_find_new_threads_1 (ptid);
498
499   err = info->td_ta_map_lwp2thr_p (info->thread_agent, GET_LWP (ptid), &th);
500   if (err != TD_OK)
501     /* Cannot find user-level thread.  */
502     return 0;
503
504   err = info->td_thr_get_info_p (&th, &ti);
505   if (err != TD_OK)
506     {
507       warning (_("Cannot get thread info: %s"), thread_db_err_str (err));
508       return 0;
509     }
510
511   attach_thread (ptid, &th, &ti);
512   return 1;
513 }
514
515 static void *
516 verbose_dlsym (void *handle, const char *name)
517 {
518   void *sym = dlsym (handle, name);
519   if (sym == NULL)
520     warning (_("Symbol \"%s\" not found in libthread_db: %s"),
521              name, dlerror ());
522   return sym;
523 }
524
525 static td_err_e
526 enable_thread_event (int event, CORE_ADDR *bp)
527 {
528   td_notify_t notify;
529   td_err_e err;
530   struct thread_db_info *info;
531
532   info = get_thread_db_info (GET_PID (inferior_ptid));
533
534   /* Access an lwp we know is stopped.  */
535   info->proc_handle.ptid = inferior_ptid;
536
537   /* Get the breakpoint address for thread EVENT.  */
538   err = info->td_ta_event_addr_p (info->thread_agent, event, &notify);
539   if (err != TD_OK)
540     return err;
541
542   /* Set up the breakpoint.  */
543   gdb_assert (exec_bfd);
544   (*bp) = (gdbarch_convert_from_func_ptr_addr
545            (target_gdbarch,
546             /* Do proper sign extension for the target.  */
547             (bfd_get_sign_extend_vma (exec_bfd) > 0
548              ? (CORE_ADDR) (intptr_t) notify.u.bptaddr
549              : (CORE_ADDR) (uintptr_t) notify.u.bptaddr),
550             &current_target));
551   create_thread_event_breakpoint (target_gdbarch, *bp);
552
553   return TD_OK;
554 }
555
556 static void
557 enable_thread_event_reporting (void)
558 {
559   td_thr_events_t events;
560   td_err_e err;
561 #ifdef HAVE_GNU_LIBC_VERSION_H
562   const char *libc_version;
563   int libc_major, libc_minor;
564 #endif
565   struct thread_db_info *info;
566
567   info = get_thread_db_info (GET_PID (inferior_ptid));
568
569   /* We cannot use the thread event reporting facility if these
570      functions aren't available.  */
571   if (info->td_ta_event_addr_p == NULL
572       || info->td_ta_set_event_p == NULL
573       || info->td_ta_event_getmsg_p == NULL
574       || info->td_thr_event_enable_p == NULL)
575     return;
576
577   /* Set the process wide mask saying which events we're interested in.  */
578   td_event_emptyset (&events);
579   td_event_addset (&events, TD_CREATE);
580
581 #ifdef HAVE_GNU_LIBC_VERSION_H
582   /* The event reporting facility is broken for TD_DEATH events in
583      glibc 2.1.3, so don't enable it if we have glibc but a lower
584      version.  */
585   libc_version = gnu_get_libc_version ();
586   if (sscanf (libc_version, "%d.%d", &libc_major, &libc_minor) == 2
587       && (libc_major > 2 || (libc_major == 2 && libc_minor > 1)))
588 #endif
589     td_event_addset (&events, TD_DEATH);
590
591   err = info->td_ta_set_event_p (info->thread_agent, &events);
592   if (err != TD_OK)
593     {
594       warning (_("Unable to set global thread event mask: %s"),
595                thread_db_err_str (err));
596       return;
597     }
598
599   /* Delete previous thread event breakpoints, if any.  */
600   remove_thread_event_breakpoints ();
601   info->td_create_bp_addr = 0;
602   info->td_death_bp_addr = 0;
603
604   /* Set up the thread creation event.  */
605   err = enable_thread_event (TD_CREATE, &info->td_create_bp_addr);
606   if (err != TD_OK)
607     {
608       warning (_("Unable to get location for thread creation breakpoint: %s"),
609                thread_db_err_str (err));
610       return;
611     }
612
613   /* Set up the thread death event.  */
614   err = enable_thread_event (TD_DEATH, &info->td_death_bp_addr);
615   if (err != TD_OK)
616     {
617       warning (_("Unable to get location for thread death breakpoint: %s"),
618                thread_db_err_str (err));
619       return;
620     }
621 }
622
623 /* Same as thread_db_find_new_threads_1, but silently ignore errors.  */
624
625 static void
626 thread_db_find_new_threads_silently (ptid_t ptid)
627 {
628   volatile struct gdb_exception except;
629
630   TRY_CATCH (except, RETURN_MASK_ERROR)
631     {
632       thread_db_find_new_threads_2 (ptid, 1);
633     }
634
635   if (except.reason < 0 && libthread_db_debug)
636     {
637       exception_fprintf (gdb_stderr, except,
638                          "Warning: thread_db_find_new_threads_silently: ");
639     }
640 }
641
642 /* Lookup a library in which given symbol resides.
643    Note: this is looking in GDB process, not in the inferior.
644    Returns library name, or NULL.  */
645
646 static const char *
647 dladdr_to_soname (const void *addr)
648 {
649   Dl_info info;
650
651   if (dladdr (addr, &info) != 0)
652     return info.dli_fname;
653   return NULL;
654 }
655
656 /* Attempt to initialize dlopen()ed libthread_db, described by INFO.
657    Return 1 on success.
658    Failure could happen if libthread_db does not have symbols we expect,
659    or when it refuses to work with the current inferior (e.g. due to
660    version mismatch between libthread_db and libpthread).  */
661
662 static int
663 try_thread_db_load_1 (struct thread_db_info *info)
664 {
665   td_err_e err;
666
667   /* Initialize pointers to the dynamic library functions we will use.
668      Essential functions first.  */
669
670   info->td_init_p = verbose_dlsym (info->handle, "td_init");
671   if (info->td_init_p == NULL)
672     return 0;
673
674   err = info->td_init_p ();
675   if (err != TD_OK)
676     {
677       warning (_("Cannot initialize libthread_db: %s"),
678                thread_db_err_str (err));
679       return 0;
680     }
681
682   info->td_ta_new_p = verbose_dlsym (info->handle, "td_ta_new");
683   if (info->td_ta_new_p == NULL)
684     return 0;
685
686   /* Initialize the structure that identifies the child process.  */
687   info->proc_handle.ptid = inferior_ptid;
688
689   /* Now attempt to open a connection to the thread library.  */
690   err = info->td_ta_new_p (&info->proc_handle, &info->thread_agent);
691   if (err != TD_OK)
692     {
693       if (libthread_db_debug)
694         printf_unfiltered (_("td_ta_new failed: %s\n"),
695                            thread_db_err_str (err));
696       else
697         switch (err)
698           {
699             case TD_NOLIBTHREAD:
700 #ifdef THREAD_DB_HAS_TD_VERSION
701             case TD_VERSION:
702 #endif
703               /* The errors above are not unexpected and silently ignored:
704                  they just mean we haven't found correct version of
705                  libthread_db yet.  */
706               break;
707             default:
708               warning (_("td_ta_new failed: %s"), thread_db_err_str (err));
709           }
710       return 0;
711     }
712
713   info->td_ta_map_id2thr_p = verbose_dlsym (info->handle, "td_ta_map_id2thr");
714   if (info->td_ta_map_id2thr_p == NULL)
715     return 0;
716
717   info->td_ta_map_lwp2thr_p = verbose_dlsym (info->handle,
718                                              "td_ta_map_lwp2thr");
719   if (info->td_ta_map_lwp2thr_p == NULL)
720     return 0;
721
722   info->td_ta_thr_iter_p = verbose_dlsym (info->handle, "td_ta_thr_iter");
723   if (info->td_ta_thr_iter_p == NULL)
724     return 0;
725
726   info->td_thr_validate_p = verbose_dlsym (info->handle, "td_thr_validate");
727   if (info->td_thr_validate_p == NULL)
728     return 0;
729
730   info->td_thr_get_info_p = verbose_dlsym (info->handle, "td_thr_get_info");
731   if (info->td_thr_get_info_p == NULL)
732     return 0;
733
734   /* These are not essential.  */
735   info->td_ta_event_addr_p = dlsym (info->handle, "td_ta_event_addr");
736   info->td_ta_set_event_p = dlsym (info->handle, "td_ta_set_event");
737   info->td_ta_clear_event_p = dlsym (info->handle, "td_ta_clear_event");
738   info->td_ta_event_getmsg_p = dlsym (info->handle, "td_ta_event_getmsg");
739   info->td_thr_event_enable_p = dlsym (info->handle, "td_thr_event_enable");
740   info->td_thr_tls_get_addr_p = dlsym (info->handle, "td_thr_tls_get_addr");
741
742   printf_unfiltered (_("[Thread debugging using libthread_db enabled]\n"));
743
744   if (libthread_db_debug || *libthread_db_search_path)
745     {
746       const char *library;
747
748       library = dladdr_to_soname (*info->td_ta_new_p);
749       if (library == NULL)
750         library = LIBTHREAD_DB_SO;
751
752       printf_unfiltered (_("Using host libthread_db library \"%s\".\n"),
753                          library);
754     }
755
756   /* The thread library was detected.  Activate the thread_db target
757      if this is the first process using it.  */
758   if (thread_db_list->next == NULL)
759     push_target (&thread_db_ops);
760
761   /* Enable event reporting, but not when debugging a core file.  */
762   if (target_has_execution)
763     enable_thread_event_reporting ();
764
765   /* There appears to be a bug in glibc-2.3.6: calls to td_thr_get_info fail
766      with TD_ERR for statically linked executables if td_thr_get_info is
767      called before glibc has initialized itself.  Silently ignore such
768      errors, and let gdb enumerate threads again later.  */
769   thread_db_find_new_threads_silently (inferior_ptid);
770
771   return 1;
772 }
773
774 /* Attempt to use LIBRARY as libthread_db.  LIBRARY could be absolute,
775    relative, or just LIBTHREAD_DB.  */
776
777 static int
778 try_thread_db_load (const char *library)
779 {
780   void *handle;
781   struct thread_db_info *info;
782
783   if (libthread_db_debug)
784     printf_unfiltered (_("Trying host libthread_db library: %s.\n"),
785                        library);
786   handle = dlopen (library, RTLD_NOW);
787   if (handle == NULL)
788     {
789       if (libthread_db_debug)
790         printf_unfiltered (_("dlopen failed: %s.\n"), dlerror ());
791       return 0;
792     }
793
794   if (libthread_db_debug && strchr (library, '/') == NULL)
795     {
796       void *td_init;
797
798       td_init = dlsym (handle, "td_init");
799       if (td_init != NULL)
800         {
801           const char *const libpath = dladdr_to_soname (td_init);
802
803           if (libpath != NULL)
804             printf_unfiltered (_("Host %s resolved to: %s.\n"),
805                                library, libpath);
806         }
807     }
808
809   info = add_thread_db_info (handle);
810
811   if (try_thread_db_load_1 (info))
812     return 1;
813
814   /* This library "refused" to work on current inferior.  */
815   delete_thread_db_info (GET_PID (inferior_ptid));
816   return 0;
817 }
818
819 /* Subroutine of try_thread_db_load_from_pdir to simplify it.
820    Try loading libthread_db from the same directory as OBJ.
821    The result is true for success.  */
822
823 static int
824 try_thread_db_load_from_pdir_1 (struct objfile *obj)
825 {
826   struct cleanup *cleanup;
827   char *path, *cp;
828   int result;
829
830   if (obj->name[0] != '/')
831     {
832       warning (_("Expected absolute pathname for libpthread in the"
833                  " inferior, but got %s."), obj->name);
834       return 0;
835     }
836
837   path = xmalloc (strlen (obj->name) + 1 + strlen (LIBTHREAD_DB_SO) + 1);
838   cleanup = make_cleanup (xfree, path);
839
840   strcpy (path, obj->name);
841   cp = strrchr (path, '/');
842   /* This should at minimum hit the first character.  */
843   gdb_assert (cp != NULL);
844   strcpy (cp + 1, LIBTHREAD_DB_SO);
845   result = try_thread_db_load (path);
846
847   do_cleanups (cleanup);
848   return result;
849 }
850
851 /* Handle $pdir in libthread-db-search-path.
852    Look for libthread_db in the directory of libpthread.
853    The result is true for success.  */
854
855 static int
856 try_thread_db_load_from_pdir (void)
857 {
858   struct objfile *obj;
859
860   ALL_OBJFILES (obj)
861     if (libpthread_name_p (obj->name))
862       {
863         if (try_thread_db_load_from_pdir_1 (obj))
864           return 1;
865
866         /* We may have found the separate-debug-info version of
867            libpthread, and it may live in a directory without a matching
868            libthread_db.  */
869         if (obj->separate_debug_objfile_backlink != NULL)
870           return try_thread_db_load_from_pdir_1 (obj->separate_debug_objfile_backlink);
871
872         return 0;
873       }
874
875   return 0;
876 }
877
878 /* Handle $sdir in libthread-db-search-path.
879    Look for libthread_db in the system dirs, or wherever a plain
880    dlopen(file_without_path) will look.
881    The result is true for success.  */
882
883 static int
884 try_thread_db_load_from_sdir (void)
885 {
886   return try_thread_db_load (LIBTHREAD_DB_SO);
887 }
888
889 /* Try to load libthread_db from directory DIR of length DIR_LEN.
890    The result is true for success.  */
891
892 static int
893 try_thread_db_load_from_dir (const char *dir, size_t dir_len)
894 {
895   struct cleanup *cleanup;
896   char *path;
897   int result;
898
899   path = xmalloc (dir_len + 1 + strlen (LIBTHREAD_DB_SO) + 1);
900   cleanup = make_cleanup (xfree, path);
901
902   memcpy (path, dir, dir_len);
903   path[dir_len] = '/';
904   strcpy (path + dir_len + 1, LIBTHREAD_DB_SO);
905   result = try_thread_db_load (path);
906
907   do_cleanups (cleanup);
908   return result;
909 }
910
911 /* Search libthread_db_search_path for libthread_db which "agrees"
912    to work on current inferior.
913    The result is true for success.  */
914
915 static int
916 thread_db_load_search (void)
917 {
918   const char *search_path = libthread_db_search_path;
919   int rc = 0;
920
921   while (*search_path)
922     {
923       const char *end = strchr (search_path, ':');
924       const char *this_dir = search_path;
925       size_t this_dir_len;
926
927       if (end)
928         {
929           this_dir_len = end - search_path;
930           search_path += this_dir_len + 1;
931         }
932       else
933         {
934           this_dir_len = strlen (this_dir);
935           search_path += this_dir_len;
936         }
937
938       if (this_dir_len == sizeof ("$pdir") - 1
939           && strncmp (this_dir, "$pdir", this_dir_len) == 0)
940         {
941           if (try_thread_db_load_from_pdir ())
942             {
943               rc = 1;
944               break;
945             }
946         }
947       else if (this_dir_len == sizeof ("$sdir") - 1
948                && strncmp (this_dir, "$sdir", this_dir_len) == 0)
949         {
950           if (try_thread_db_load_from_sdir ())
951             {
952               rc = 1;
953               break;
954             }
955         }
956       else
957         {
958           if (try_thread_db_load_from_dir (this_dir, this_dir_len))
959             {
960               rc = 1;
961               break;
962             }
963         }
964     }
965
966   if (libthread_db_debug)
967     printf_unfiltered (_("thread_db_load_search returning %d\n"), rc);
968   return rc;
969 }
970
971 /* Return non-zero if the inferior has a libpthread.  */
972
973 static int
974 has_libpthread (void)
975 {
976   struct objfile *obj;
977
978   ALL_OBJFILES (obj)
979     if (libpthread_name_p (obj->name))
980       return 1;
981
982   return 0;
983 }
984
985 /* Attempt to load and initialize libthread_db.
986    Return 1 on success.  */
987
988 static int
989 thread_db_load (void)
990 {
991   struct thread_db_info *info;
992
993   info = get_thread_db_info (GET_PID (inferior_ptid));
994
995   if (info != NULL)
996     return 1;
997
998   /* Don't attempt to use thread_db on executables not running
999      yet.  */
1000   if (!target_has_registers)
1001     return 0;
1002
1003   /* Don't attempt to use thread_db for remote targets.  */
1004   if (!(target_can_run (&current_target) || core_bfd))
1005     return 0;
1006
1007   if (thread_db_load_search ())
1008     return 1;
1009
1010   /* We couldn't find a libthread_db.
1011      If the inferior has a libpthread warn the user.  */
1012   if (has_libpthread ())
1013     {
1014       warning (_("Unable to find libthread_db matching inferior's thread"
1015                  " library, thread debugging will not be available."));
1016       return 0;
1017     }
1018
1019   /* Either this executable isn't using libpthread at all, or it is
1020      statically linked.  Since we can't easily distinguish these two cases,
1021      no warning is issued.  */
1022   return 0;
1023 }
1024
1025 static void
1026 disable_thread_event_reporting (struct thread_db_info *info)
1027 {
1028   if (info->td_ta_clear_event_p != NULL)
1029     {
1030       td_thr_events_t events;
1031
1032       /* Set the process wide mask saying we aren't interested in any
1033          events anymore.  */
1034       td_event_fillset (&events);
1035       info->td_ta_clear_event_p (info->thread_agent, &events);
1036     }
1037
1038   info->td_create_bp_addr = 0;
1039   info->td_death_bp_addr = 0;
1040 }
1041
1042 static void
1043 check_thread_signals (void)
1044 {
1045   if (!thread_signals)
1046     {
1047       sigset_t mask;
1048       int i;
1049
1050       lin_thread_get_thread_signals (&mask);
1051       sigemptyset (&thread_stop_set);
1052       sigemptyset (&thread_print_set);
1053
1054       for (i = 1; i < NSIG; i++)
1055         {
1056           if (sigismember (&mask, i))
1057             {
1058               if (signal_stop_update (target_signal_from_host (i), 0))
1059                 sigaddset (&thread_stop_set, i);
1060               if (signal_print_update (target_signal_from_host (i), 0))
1061                 sigaddset (&thread_print_set, i);
1062               thread_signals = 1;
1063             }
1064         }
1065     }
1066 }
1067
1068 /* Check whether thread_db is usable.  This function is called when
1069    an inferior is created (or otherwise acquired, e.g. attached to)
1070    and when new shared libraries are loaded into a running process.  */
1071
1072 void
1073 check_for_thread_db (void)
1074 {
1075   /* Do nothing if we couldn't load libthread_db.so.1.  */
1076   if (!thread_db_load ())
1077     return;
1078 }
1079
1080 static void
1081 thread_db_new_objfile (struct objfile *objfile)
1082 {
1083   /* This observer must always be called with inferior_ptid set
1084      correctly.  */
1085
1086   if (objfile != NULL)
1087     check_for_thread_db ();
1088 }
1089
1090 /* Attach to a new thread.  This function is called when we receive a
1091    TD_CREATE event or when we iterate over all threads and find one
1092    that wasn't already in our list.  Returns true on success.  */
1093
1094 static int
1095 attach_thread (ptid_t ptid, const td_thrhandle_t *th_p,
1096                const td_thrinfo_t *ti_p)
1097 {
1098   struct private_thread_info *private;
1099   struct thread_info *tp = NULL;
1100   td_err_e err;
1101   struct thread_db_info *info;
1102
1103   /* If we're being called after a TD_CREATE event, we may already
1104      know about this thread.  There are two ways this can happen.  We
1105      may have iterated over all threads between the thread creation
1106      and the TD_CREATE event, for instance when the user has issued
1107      the `info threads' command before the SIGTRAP for hitting the
1108      thread creation breakpoint was reported.  Alternatively, the
1109      thread may have exited and a new one been created with the same
1110      thread ID.  In the first case we don't need to do anything; in
1111      the second case we should discard information about the dead
1112      thread and attach to the new one.  */
1113   if (in_thread_list (ptid))
1114     {
1115       tp = find_thread_ptid (ptid);
1116       gdb_assert (tp != NULL);
1117
1118       /* If tp->private is NULL, then GDB is already attached to this
1119          thread, but we do not know anything about it.  We can learn
1120          about it here.  This can only happen if we have some other
1121          way besides libthread_db to notice new threads (i.e.
1122          PTRACE_EVENT_CLONE); assume the same mechanism notices thread
1123          exit, so this can not be a stale thread recreated with the
1124          same ID.  */
1125       if (tp->private != NULL)
1126         {
1127           if (!tp->private->dying)
1128             return 0;
1129
1130           delete_thread (ptid);
1131           tp = NULL;
1132         }
1133     }
1134
1135   if (target_has_execution)
1136     check_thread_signals ();
1137
1138   if (ti_p->ti_state == TD_THR_UNKNOWN || ti_p->ti_state == TD_THR_ZOMBIE)
1139     return 0;                   /* A zombie thread -- do not attach.  */
1140
1141   /* Under GNU/Linux, we have to attach to each and every thread.  */
1142   if (target_has_execution
1143       && tp == NULL)
1144     {
1145       int res;
1146
1147       res = lin_lwp_attach_lwp (BUILD_LWP (ti_p->ti_lid, GET_PID (ptid)));
1148       if (res < 0)
1149         {
1150           /* Error, stop iterating.  */
1151           return 0;
1152         }
1153       else if (res > 0)
1154         {
1155           /* Pretend this thread doesn't exist yet, and keep
1156              iterating.  */
1157           return 1;
1158         }
1159
1160       /* Otherwise, we sucessfully attached to the thread.  */
1161     }
1162
1163   /* Construct the thread's private data.  */
1164   private = xmalloc (sizeof (struct private_thread_info));
1165   memset (private, 0, sizeof (struct private_thread_info));
1166
1167   /* A thread ID of zero may mean the thread library has not initialized
1168      yet.  But we shouldn't even get here if that's the case.  FIXME:
1169      if we change GDB to always have at least one thread in the thread
1170      list this will have to go somewhere else; maybe private == NULL
1171      until the thread_db target claims it.  */
1172   gdb_assert (ti_p->ti_tid != 0);
1173   private->th = *th_p;
1174   private->tid = ti_p->ti_tid;
1175
1176   /* Add the thread to GDB's thread list.  */
1177   if (tp == NULL)
1178     add_thread_with_info (ptid, private);
1179   else
1180     tp->private = private;
1181
1182   info = get_thread_db_info (GET_PID (ptid));
1183
1184   /* Enable thread event reporting for this thread, except when
1185      debugging a core file.  */
1186   if (target_has_execution)
1187     {
1188       err = info->td_thr_event_enable_p (th_p, 1);
1189       if (err != TD_OK)
1190         error (_("Cannot enable thread event reporting for %s: %s"),
1191                target_pid_to_str (ptid), thread_db_err_str (err));
1192     }
1193
1194   return 1;
1195 }
1196
1197 static void
1198 detach_thread (ptid_t ptid)
1199 {
1200   struct thread_info *thread_info;
1201
1202   /* Don't delete the thread now, because it still reports as active
1203      until it has executed a few instructions after the event
1204      breakpoint - if we deleted it now, "info threads" would cause us
1205      to re-attach to it.  Just mark it as having had a TD_DEATH
1206      event.  This means that we won't delete it from our thread list
1207      until we notice that it's dead (via prune_threads), or until
1208      something re-uses its thread ID.  We'll report the thread exit
1209      when the underlying LWP dies.  */
1210   thread_info = find_thread_ptid (ptid);
1211   gdb_assert (thread_info != NULL && thread_info->private != NULL);
1212   thread_info->private->dying = 1;
1213 }
1214
1215 static void
1216 thread_db_detach (struct target_ops *ops, char *args, int from_tty)
1217 {
1218   struct target_ops *target_beneath = find_target_beneath (ops);
1219   struct thread_db_info *info;
1220
1221   info = get_thread_db_info (GET_PID (inferior_ptid));
1222
1223   if (info)
1224     {
1225       if (target_has_execution)
1226         {
1227           disable_thread_event_reporting (info);
1228
1229           /* Delete the old thread event breakpoints.  Note that
1230              unlike when mourning, we can remove them here because
1231              there's still a live inferior to poke at.  In any case,
1232              GDB will not try to insert anything in the inferior when
1233              removing a breakpoint.  */
1234           remove_thread_event_breakpoints ();
1235         }
1236
1237       delete_thread_db_info (GET_PID (inferior_ptid));
1238     }
1239
1240   target_beneath->to_detach (target_beneath, args, from_tty);
1241
1242   /* NOTE: From this point on, inferior_ptid is null_ptid.  */
1243
1244   /* If there are no more processes using libpthread, detach the
1245      thread_db target ops.  */
1246   if (!thread_db_list)
1247     unpush_target (&thread_db_ops);
1248 }
1249
1250 /* Check if PID is currently stopped at the location of a thread event
1251    breakpoint location.  If it is, read the event message and act upon
1252    the event.  */
1253
1254 static void
1255 check_event (ptid_t ptid)
1256 {
1257   struct regcache *regcache = get_thread_regcache (ptid);
1258   struct gdbarch *gdbarch = get_regcache_arch (regcache);
1259   td_event_msg_t msg;
1260   td_thrinfo_t ti;
1261   td_err_e err;
1262   CORE_ADDR stop_pc;
1263   int loop = 0;
1264   struct thread_db_info *info;
1265
1266   info = get_thread_db_info (GET_PID (ptid));
1267
1268   /* Bail out early if we're not at a thread event breakpoint.  */
1269   stop_pc = regcache_read_pc (regcache)
1270             - gdbarch_decr_pc_after_break (gdbarch);
1271   if (stop_pc != info->td_create_bp_addr
1272       && stop_pc != info->td_death_bp_addr)
1273     return;
1274
1275   /* Access an lwp we know is stopped.  */
1276   info->proc_handle.ptid = ptid;
1277
1278   /* If we have only looked at the first thread before libpthread was
1279      initialized, we may not know its thread ID yet.  Make sure we do
1280      before we add another thread to the list.  */
1281   if (!have_threads (ptid))
1282     thread_db_find_new_threads_1 (ptid);
1283
1284   /* If we are at a create breakpoint, we do not know what new lwp
1285      was created and cannot specifically locate the event message for it.
1286      We have to call td_ta_event_getmsg() to get
1287      the latest message.  Since we have no way of correlating whether
1288      the event message we get back corresponds to our breakpoint, we must
1289      loop and read all event messages, processing them appropriately.
1290      This guarantees we will process the correct message before continuing
1291      from the breakpoint.
1292
1293      Currently, death events are not enabled.  If they are enabled,
1294      the death event can use the td_thr_event_getmsg() interface to
1295      get the message specifically for that lwp and avoid looping
1296      below.  */
1297
1298   loop = 1;
1299
1300   do
1301     {
1302       err = info->td_ta_event_getmsg_p (info->thread_agent, &msg);
1303       if (err != TD_OK)
1304         {
1305           if (err == TD_NOMSG)
1306             return;
1307
1308           error (_("Cannot get thread event message: %s"),
1309                  thread_db_err_str (err));
1310         }
1311
1312       err = info->td_thr_get_info_p (msg.th_p, &ti);
1313       if (err != TD_OK)
1314         error (_("Cannot get thread info: %s"), thread_db_err_str (err));
1315
1316       ptid = ptid_build (GET_PID (ptid), ti.ti_lid, 0);
1317
1318       switch (msg.event)
1319         {
1320         case TD_CREATE:
1321           /* Call attach_thread whether or not we already know about a
1322              thread with this thread ID.  */
1323           attach_thread (ptid, msg.th_p, &ti);
1324
1325           break;
1326
1327         case TD_DEATH:
1328
1329           if (!in_thread_list (ptid))
1330             error (_("Spurious thread death event."));
1331
1332           detach_thread (ptid);
1333
1334           break;
1335
1336         default:
1337           error (_("Spurious thread event."));
1338         }
1339     }
1340   while (loop);
1341 }
1342
1343 static ptid_t
1344 thread_db_wait (struct target_ops *ops,
1345                 ptid_t ptid, struct target_waitstatus *ourstatus,
1346                 int options)
1347 {
1348   struct thread_db_info *info;
1349   struct target_ops *beneath = find_target_beneath (ops);
1350
1351   ptid = beneath->to_wait (beneath, ptid, ourstatus, options);
1352
1353   if (ourstatus->kind == TARGET_WAITKIND_IGNORE)
1354     return ptid;
1355
1356   if (ourstatus->kind == TARGET_WAITKIND_EXITED
1357       || ourstatus->kind == TARGET_WAITKIND_SIGNALLED)
1358     return ptid;
1359
1360   info = get_thread_db_info (GET_PID (ptid));
1361
1362   /* If this process isn't using thread_db, we're done.  */
1363   if (info == NULL)
1364     return ptid;
1365
1366   if (ourstatus->kind == TARGET_WAITKIND_EXECD)
1367     {
1368       /* New image, it may or may not end up using thread_db.  Assume
1369          not unless we find otherwise.  */
1370       delete_thread_db_info (GET_PID (ptid));
1371       if (!thread_db_list)
1372         unpush_target (&thread_db_ops);
1373
1374       /* Thread event breakpoints are deleted by
1375          update_breakpoints_after_exec.  */
1376
1377       return ptid;
1378     }
1379
1380   /* If we do not know about the main thread yet, this would be a good time to
1381      find it.  */
1382   if (ourstatus->kind == TARGET_WAITKIND_STOPPED && !have_threads (ptid))
1383     thread_db_find_new_threads_1 (ptid);
1384
1385   if (ourstatus->kind == TARGET_WAITKIND_STOPPED
1386       && ourstatus->value.sig == TARGET_SIGNAL_TRAP)
1387     /* Check for a thread event.  */
1388     check_event (ptid);
1389
1390   if (have_threads (ptid))
1391     {
1392       /* Change ptids back into the higher level PID + TID format.  If
1393          the thread is dead and no longer on the thread list, we will
1394          get back a dead ptid.  This can occur if the thread death
1395          event gets postponed by other simultaneous events.  In such a
1396          case, we want to just ignore the event and continue on.  */
1397
1398       ptid = thread_from_lwp (ptid);
1399       if (GET_PID (ptid) == -1)
1400         ourstatus->kind = TARGET_WAITKIND_SPURIOUS;
1401     }
1402
1403   return ptid;
1404 }
1405
1406 static void
1407 thread_db_mourn_inferior (struct target_ops *ops)
1408 {
1409   struct target_ops *target_beneath = find_target_beneath (ops);
1410
1411   delete_thread_db_info (GET_PID (inferior_ptid));
1412
1413   target_beneath->to_mourn_inferior (target_beneath);
1414
1415   /* Delete the old thread event breakpoints.  Do this after mourning
1416      the inferior, so that we don't try to uninsert them.  */
1417   remove_thread_event_breakpoints ();
1418
1419   /* Detach thread_db target ops.  */
1420   if (!thread_db_list)
1421     unpush_target (ops);
1422 }
1423
1424 struct callback_data
1425 {
1426   struct thread_db_info *info;
1427   int new_threads;
1428 };
1429
1430 static int
1431 find_new_threads_callback (const td_thrhandle_t *th_p, void *data)
1432 {
1433   td_thrinfo_t ti;
1434   td_err_e err;
1435   ptid_t ptid;
1436   struct thread_info *tp;
1437   struct callback_data *cb_data = data;
1438   struct thread_db_info *info = cb_data->info;
1439
1440   err = info->td_thr_get_info_p (th_p, &ti);
1441   if (err != TD_OK)
1442     error (_("find_new_threads_callback: cannot get thread info: %s"),
1443            thread_db_err_str (err));
1444
1445   if (ti.ti_state == TD_THR_UNKNOWN || ti.ti_state == TD_THR_ZOMBIE)
1446     return 0;                   /* A zombie -- ignore.  */
1447
1448   if (ti.ti_tid == 0)
1449     {
1450       /* A thread ID of zero means that this is the main thread, but
1451          glibc has not yet initialized thread-local storage and the
1452          pthread library.  We do not know what the thread's TID will
1453          be yet.  Just enable event reporting and otherwise ignore
1454          it.  */
1455
1456       /* In that case, we're not stopped in a fork syscall and don't
1457          need this glibc bug workaround.  */
1458       info->need_stale_parent_threads_check = 0;
1459
1460       if (target_has_execution)
1461         {
1462           err = info->td_thr_event_enable_p (th_p, 1);
1463           if (err != TD_OK)
1464             error (_("Cannot enable thread event reporting for LWP %d: %s"),
1465                    (int) ti.ti_lid, thread_db_err_str (err));
1466         }
1467
1468       return 0;
1469     }
1470
1471   /* Ignore stale parent threads, caused by glibc/BZ5983.  This is a
1472      bit expensive, as it needs to open /proc/pid/status, so try to
1473      avoid doing the work if we know we don't have to.  */
1474   if (info->need_stale_parent_threads_check)
1475     {
1476       int tgid = linux_proc_get_tgid (ti.ti_lid);
1477
1478       if (tgid != -1 && tgid != info->pid)
1479         return 0;
1480     }
1481
1482   ptid = ptid_build (info->pid, ti.ti_lid, 0);
1483   tp = find_thread_ptid (ptid);
1484   if (tp == NULL || tp->private == NULL)
1485     {
1486       if (attach_thread (ptid, th_p, &ti))
1487         cb_data->new_threads += 1;
1488       else
1489         /* Problem attaching this thread; perhaps it exited before we
1490            could attach it?
1491            This could mean that the thread list inside glibc itself is in
1492            inconsistent state, and libthread_db could go on looping forever
1493            (observed with glibc-2.3.6).  To prevent that, terminate
1494            iteration: thread_db_find_new_threads_2 will retry.  */
1495         return 1;
1496     }
1497
1498   return 0;
1499 }
1500
1501 /* Helper for thread_db_find_new_threads_2.
1502    Returns number of new threads found.  */
1503
1504 static int
1505 find_new_threads_once (struct thread_db_info *info, int iteration,
1506                        td_err_e *errp)
1507 {
1508   volatile struct gdb_exception except;
1509   struct callback_data data;
1510   td_err_e err = TD_ERR;
1511
1512   data.info = info;
1513   data.new_threads = 0;
1514
1515   TRY_CATCH (except, RETURN_MASK_ERROR)
1516     {
1517       /* Iterate over all user-space threads to discover new threads.  */
1518       err = info->td_ta_thr_iter_p (info->thread_agent,
1519                                     find_new_threads_callback,
1520                                     &data,
1521                                     TD_THR_ANY_STATE,
1522                                     TD_THR_LOWEST_PRIORITY,
1523                                     TD_SIGNO_MASK,
1524                                     TD_THR_ANY_USER_FLAGS);
1525     }
1526
1527   if (libthread_db_debug)
1528     {
1529       if (except.reason < 0)
1530         exception_fprintf (gdb_stderr, except,
1531                            "Warning: find_new_threads_once: ");
1532
1533       printf_filtered (_("Found %d new threads in iteration %d.\n"),
1534                        data.new_threads, iteration);
1535     }
1536
1537   if (errp != NULL)
1538     *errp = err;
1539
1540   return data.new_threads;
1541 }
1542
1543 /* Search for new threads, accessing memory through stopped thread
1544    PTID.  If UNTIL_NO_NEW is true, repeat searching until several
1545    searches in a row do not discover any new threads.  */
1546
1547 static void
1548 thread_db_find_new_threads_2 (ptid_t ptid, int until_no_new)
1549 {
1550   td_err_e err;
1551   struct thread_db_info *info;
1552   int pid = ptid_get_pid (ptid);
1553   int i, loop;
1554
1555   if (target_has_execution)
1556     {
1557       struct lwp_info *lp;
1558
1559       /* In linux, we can only read memory through a stopped lwp.  */
1560       ALL_LWPS (lp, ptid)
1561         if (lp->stopped && ptid_get_pid (lp->ptid) == pid)
1562           break;
1563
1564       if (!lp)
1565         /* There is no stopped thread.  Bail out.  */
1566         return;
1567     }
1568
1569   info = get_thread_db_info (GET_PID (ptid));
1570
1571   /* Access an lwp we know is stopped.  */
1572   info->proc_handle.ptid = ptid;
1573
1574   if (until_no_new)
1575     {
1576       /* Require 4 successive iterations which do not find any new threads.
1577          The 4 is a heuristic: there is an inherent race here, and I have
1578          seen that 2 iterations in a row are not always sufficient to
1579          "capture" all threads.  */
1580       for (i = 0, loop = 0; loop < 4; ++i, ++loop)
1581         if (find_new_threads_once (info, i, NULL) != 0)
1582           /* Found some new threads.  Restart the loop from beginning.  */
1583           loop = -1;
1584     }
1585   else
1586     {
1587       find_new_threads_once (info, 0, &err);
1588       if (err != TD_OK)
1589         error (_("Cannot find new threads: %s"), thread_db_err_str (err));
1590     }
1591 }
1592
1593 static void
1594 thread_db_find_new_threads_1 (ptid_t ptid)
1595 {
1596   thread_db_find_new_threads_2 (ptid, 0);
1597 }
1598
1599 static int
1600 update_thread_core (struct lwp_info *info, void *closure)
1601 {
1602   info->core = linux_nat_core_of_thread_1 (info->ptid);
1603   return 0;
1604 }
1605
1606 static void
1607 thread_db_find_new_threads (struct target_ops *ops)
1608 {
1609   struct thread_db_info *info;
1610
1611   info = get_thread_db_info (GET_PID (inferior_ptid));
1612
1613   if (info == NULL)
1614     return;
1615
1616   thread_db_find_new_threads_1 (inferior_ptid);
1617
1618   if (target_has_execution)
1619     iterate_over_lwps (minus_one_ptid /* iterate over all */,
1620                        update_thread_core, NULL);
1621 }
1622
1623 static char *
1624 thread_db_pid_to_str (struct target_ops *ops, ptid_t ptid)
1625 {
1626   struct thread_info *thread_info = find_thread_ptid (ptid);
1627   struct target_ops *beneath;
1628
1629   if (thread_info != NULL && thread_info->private != NULL)
1630     {
1631       static char buf[64];
1632       thread_t tid;
1633
1634       tid = thread_info->private->tid;
1635       snprintf (buf, sizeof (buf), "Thread 0x%lx (LWP %ld)",
1636                 tid, GET_LWP (ptid));
1637
1638       return buf;
1639     }
1640
1641   beneath = find_target_beneath (ops);
1642   if (beneath->to_pid_to_str (beneath, ptid))
1643     return beneath->to_pid_to_str (beneath, ptid);
1644
1645   return normal_pid_to_str (ptid);
1646 }
1647
1648 /* Return a string describing the state of the thread specified by
1649    INFO.  */
1650
1651 static char *
1652 thread_db_extra_thread_info (struct thread_info *info)
1653 {
1654   if (info->private == NULL)
1655     return NULL;
1656
1657   if (info->private->dying)
1658     return "Exiting";
1659
1660   return NULL;
1661 }
1662
1663 /* Get the address of the thread local variable in load module LM which
1664    is stored at OFFSET within the thread local storage for thread PTID.  */
1665
1666 static CORE_ADDR
1667 thread_db_get_thread_local_address (struct target_ops *ops,
1668                                     ptid_t ptid,
1669                                     CORE_ADDR lm,
1670                                     CORE_ADDR offset)
1671 {
1672   struct thread_info *thread_info;
1673   struct target_ops *beneath;
1674
1675   /* If we have not discovered any threads yet, check now.  */
1676   if (!have_threads (ptid))
1677     thread_db_find_new_threads_1 (ptid);
1678
1679   /* Find the matching thread.  */
1680   thread_info = find_thread_ptid (ptid);
1681
1682   if (thread_info != NULL && thread_info->private != NULL)
1683     {
1684       td_err_e err;
1685       psaddr_t address;
1686       struct thread_db_info *info;
1687
1688       info = get_thread_db_info (GET_PID (ptid));
1689
1690       /* glibc doesn't provide the needed interface.  */
1691       if (!info->td_thr_tls_get_addr_p)
1692         throw_error (TLS_NO_LIBRARY_SUPPORT_ERROR,
1693                      _("No TLS library support"));
1694
1695       /* Caller should have verified that lm != 0.  */
1696       gdb_assert (lm != 0);
1697
1698       /* Finally, get the address of the variable.  */
1699       /* Note the cast through uintptr_t: this interface only works if
1700          a target address fits in a psaddr_t, which is a host pointer.
1701          So a 32-bit debugger can not access 64-bit TLS through this.  */
1702       err = info->td_thr_tls_get_addr_p (&thread_info->private->th,
1703                                          (psaddr_t)(uintptr_t) lm,
1704                                          offset, &address);
1705
1706 #ifdef THREAD_DB_HAS_TD_NOTALLOC
1707       /* The memory hasn't been allocated, yet.  */
1708       if (err == TD_NOTALLOC)
1709           /* Now, if libthread_db provided the initialization image's
1710              address, we *could* try to build a non-lvalue value from
1711              the initialization image.  */
1712         throw_error (TLS_NOT_ALLOCATED_YET_ERROR,
1713                      _("TLS not allocated yet"));
1714 #endif
1715
1716       /* Something else went wrong.  */
1717       if (err != TD_OK)
1718         throw_error (TLS_GENERIC_ERROR,
1719                      (("%s")), thread_db_err_str (err));
1720
1721       /* Cast assuming host == target.  Joy.  */
1722       /* Do proper sign extension for the target.  */
1723       gdb_assert (exec_bfd);
1724       return (bfd_get_sign_extend_vma (exec_bfd) > 0
1725               ? (CORE_ADDR) (intptr_t) address
1726               : (CORE_ADDR) (uintptr_t) address);
1727     }
1728
1729   beneath = find_target_beneath (ops);
1730   if (beneath->to_get_thread_local_address)
1731     return beneath->to_get_thread_local_address (beneath, ptid, lm, offset);
1732   else
1733     throw_error (TLS_GENERIC_ERROR,
1734                  _("TLS not supported on this target"));
1735 }
1736
1737 /* Callback routine used to find a thread based on the TID part of
1738    its PTID.  */
1739
1740 static int
1741 thread_db_find_thread_from_tid (struct thread_info *thread, void *data)
1742 {
1743   long *tid = (long *) data;
1744
1745   if (thread->private->tid == *tid)
1746     return 1;
1747
1748   return 0;
1749 }
1750
1751 /* Implement the to_get_ada_task_ptid target method for this target.  */
1752
1753 static ptid_t
1754 thread_db_get_ada_task_ptid (long lwp, long thread)
1755 {
1756   struct thread_info *thread_info;
1757
1758   thread_db_find_new_threads_1 (inferior_ptid);
1759   thread_info = iterate_over_threads (thread_db_find_thread_from_tid, &thread);
1760
1761   gdb_assert (thread_info != NULL);
1762
1763   return (thread_info->ptid);
1764 }
1765
1766 static void
1767 thread_db_resume (struct target_ops *ops,
1768                   ptid_t ptid, int step, enum target_signal signo)
1769 {
1770   struct target_ops *beneath = find_target_beneath (ops);
1771   struct thread_db_info *info;
1772
1773   if (ptid_equal (ptid, minus_one_ptid))
1774     info = get_thread_db_info (GET_PID (inferior_ptid));
1775   else
1776     info = get_thread_db_info (GET_PID (ptid));
1777
1778   /* This workaround is only needed for child fork lwps stopped in a
1779      PTRACE_O_TRACEFORK event.  When the inferior is resumed, the
1780      workaround can be disabled.  */
1781   if (info)
1782     info->need_stale_parent_threads_check = 0;
1783
1784   beneath->to_resume (beneath, ptid, step, signo);
1785 }
1786
1787 static void
1788 init_thread_db_ops (void)
1789 {
1790   thread_db_ops.to_shortname = "multi-thread";
1791   thread_db_ops.to_longname = "multi-threaded child process.";
1792   thread_db_ops.to_doc = "Threads and pthreads support.";
1793   thread_db_ops.to_detach = thread_db_detach;
1794   thread_db_ops.to_wait = thread_db_wait;
1795   thread_db_ops.to_resume = thread_db_resume;
1796   thread_db_ops.to_mourn_inferior = thread_db_mourn_inferior;
1797   thread_db_ops.to_find_new_threads = thread_db_find_new_threads;
1798   thread_db_ops.to_pid_to_str = thread_db_pid_to_str;
1799   thread_db_ops.to_stratum = thread_stratum;
1800   thread_db_ops.to_has_thread_control = tc_schedlock;
1801   thread_db_ops.to_get_thread_local_address
1802     = thread_db_get_thread_local_address;
1803   thread_db_ops.to_extra_thread_info = thread_db_extra_thread_info;
1804   thread_db_ops.to_get_ada_task_ptid = thread_db_get_ada_task_ptid;
1805   thread_db_ops.to_magic = OPS_MAGIC;
1806 }
1807
1808 /* Provide a prototype to silence -Wmissing-prototypes.  */
1809 extern initialize_file_ftype _initialize_thread_db;
1810
1811 void
1812 _initialize_thread_db (void)
1813 {
1814   init_thread_db_ops ();
1815   add_target (&thread_db_ops);
1816
1817   /* Defer loading of libthread_db.so until inferior is running.
1818      This allows gdb to load correct libthread_db for a given
1819      executable -- there could be mutiple versions of glibc,
1820      compiled with LinuxThreads or NPTL, and until there is
1821      a running inferior, we can't tell which libthread_db is
1822      the correct one to load.  */
1823
1824   libthread_db_search_path = xstrdup (LIBTHREAD_DB_SEARCH_PATH);
1825
1826   add_setshow_optional_filename_cmd ("libthread-db-search-path",
1827                                      class_support,
1828                                      &libthread_db_search_path, _("\
1829 Set search path for libthread_db."), _("\
1830 Show the current search path or libthread_db."), _("\
1831 This path is used to search for libthread_db to be loaded into \
1832 gdb itself.\n\
1833 Its value is a colon (':') separate list of directories to search.\n\
1834 Setting the search path to an empty list resets it to its default value."),
1835                             set_libthread_db_search_path,
1836                             NULL,
1837                             &setlist, &showlist);
1838
1839   add_setshow_zinteger_cmd ("libthread-db", class_maintenance,
1840                             &libthread_db_debug, _("\
1841 Set libthread-db debugging."), _("\
1842 Show libthread-db debugging."), _("\
1843 When non-zero, libthread-db debugging is enabled."),
1844                             NULL,
1845                             show_libthread_db_debug,
1846                             &setdebuglist, &showdebuglist);
1847
1848   /* Add ourselves to objfile event chain.  */
1849   observer_attach_new_objfile (thread_db_new_objfile);
1850 }