* linux-thread-db.c (thread_db_new_objfile): Only try to load
[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 /* This function is called via the new_objfile observer.  */
1081
1082 static void
1083 thread_db_new_objfile (struct objfile *objfile)
1084 {
1085   /* This observer must always be called with inferior_ptid set
1086      correctly.  */
1087
1088   if (objfile != NULL
1089       /* Only check for thread_db if we loaded libpthread,
1090          or if this is the main symbol file.
1091          We need to check OBJF_MAINLINE to handle the case of debugging
1092          a statically linked executable AND the symbol file is specified AFTER
1093          the exec file is loaded (e.g., gdb -c core ; file foo).
1094          For dynamically linked executables, libpthread can be near the end
1095          of the list of shared libraries to load, and in an app of several
1096          thousand shared libraries, this can otherwise be painful.  */
1097       && ((objfile->flags & OBJF_MAINLINE) != 0
1098           || libpthread_name_p (objfile->name)))
1099     check_for_thread_db ();
1100 }
1101
1102 /* This function is called via the inferior_created observer.
1103    This handles the case of debugging statically linked executables.  */
1104
1105 static void
1106 thread_db_inferior_created (struct target_ops *target, int from_tty)
1107 {
1108   check_for_thread_db ();
1109 }
1110
1111 /* Attach to a new thread.  This function is called when we receive a
1112    TD_CREATE event or when we iterate over all threads and find one
1113    that wasn't already in our list.  Returns true on success.  */
1114
1115 static int
1116 attach_thread (ptid_t ptid, const td_thrhandle_t *th_p,
1117                const td_thrinfo_t *ti_p)
1118 {
1119   struct private_thread_info *private;
1120   struct thread_info *tp = NULL;
1121   td_err_e err;
1122   struct thread_db_info *info;
1123
1124   /* If we're being called after a TD_CREATE event, we may already
1125      know about this thread.  There are two ways this can happen.  We
1126      may have iterated over all threads between the thread creation
1127      and the TD_CREATE event, for instance when the user has issued
1128      the `info threads' command before the SIGTRAP for hitting the
1129      thread creation breakpoint was reported.  Alternatively, the
1130      thread may have exited and a new one been created with the same
1131      thread ID.  In the first case we don't need to do anything; in
1132      the second case we should discard information about the dead
1133      thread and attach to the new one.  */
1134   if (in_thread_list (ptid))
1135     {
1136       tp = find_thread_ptid (ptid);
1137       gdb_assert (tp != NULL);
1138
1139       /* If tp->private is NULL, then GDB is already attached to this
1140          thread, but we do not know anything about it.  We can learn
1141          about it here.  This can only happen if we have some other
1142          way besides libthread_db to notice new threads (i.e.
1143          PTRACE_EVENT_CLONE); assume the same mechanism notices thread
1144          exit, so this can not be a stale thread recreated with the
1145          same ID.  */
1146       if (tp->private != NULL)
1147         {
1148           if (!tp->private->dying)
1149             return 0;
1150
1151           delete_thread (ptid);
1152           tp = NULL;
1153         }
1154     }
1155
1156   if (target_has_execution)
1157     check_thread_signals ();
1158
1159   if (ti_p->ti_state == TD_THR_UNKNOWN || ti_p->ti_state == TD_THR_ZOMBIE)
1160     return 0;                   /* A zombie thread -- do not attach.  */
1161
1162   /* Under GNU/Linux, we have to attach to each and every thread.  */
1163   if (target_has_execution
1164       && tp == NULL)
1165     {
1166       int res;
1167
1168       res = lin_lwp_attach_lwp (BUILD_LWP (ti_p->ti_lid, GET_PID (ptid)));
1169       if (res < 0)
1170         {
1171           /* Error, stop iterating.  */
1172           return 0;
1173         }
1174       else if (res > 0)
1175         {
1176           /* Pretend this thread doesn't exist yet, and keep
1177              iterating.  */
1178           return 1;
1179         }
1180
1181       /* Otherwise, we sucessfully attached to the thread.  */
1182     }
1183
1184   /* Construct the thread's private data.  */
1185   private = xmalloc (sizeof (struct private_thread_info));
1186   memset (private, 0, sizeof (struct private_thread_info));
1187
1188   /* A thread ID of zero may mean the thread library has not initialized
1189      yet.  But we shouldn't even get here if that's the case.  FIXME:
1190      if we change GDB to always have at least one thread in the thread
1191      list this will have to go somewhere else; maybe private == NULL
1192      until the thread_db target claims it.  */
1193   gdb_assert (ti_p->ti_tid != 0);
1194   private->th = *th_p;
1195   private->tid = ti_p->ti_tid;
1196
1197   /* Add the thread to GDB's thread list.  */
1198   if (tp == NULL)
1199     add_thread_with_info (ptid, private);
1200   else
1201     tp->private = private;
1202
1203   info = get_thread_db_info (GET_PID (ptid));
1204
1205   /* Enable thread event reporting for this thread, except when
1206      debugging a core file.  */
1207   if (target_has_execution)
1208     {
1209       err = info->td_thr_event_enable_p (th_p, 1);
1210       if (err != TD_OK)
1211         error (_("Cannot enable thread event reporting for %s: %s"),
1212                target_pid_to_str (ptid), thread_db_err_str (err));
1213     }
1214
1215   return 1;
1216 }
1217
1218 static void
1219 detach_thread (ptid_t ptid)
1220 {
1221   struct thread_info *thread_info;
1222
1223   /* Don't delete the thread now, because it still reports as active
1224      until it has executed a few instructions after the event
1225      breakpoint - if we deleted it now, "info threads" would cause us
1226      to re-attach to it.  Just mark it as having had a TD_DEATH
1227      event.  This means that we won't delete it from our thread list
1228      until we notice that it's dead (via prune_threads), or until
1229      something re-uses its thread ID.  We'll report the thread exit
1230      when the underlying LWP dies.  */
1231   thread_info = find_thread_ptid (ptid);
1232   gdb_assert (thread_info != NULL && thread_info->private != NULL);
1233   thread_info->private->dying = 1;
1234 }
1235
1236 static void
1237 thread_db_detach (struct target_ops *ops, char *args, int from_tty)
1238 {
1239   struct target_ops *target_beneath = find_target_beneath (ops);
1240   struct thread_db_info *info;
1241
1242   info = get_thread_db_info (GET_PID (inferior_ptid));
1243
1244   if (info)
1245     {
1246       if (target_has_execution)
1247         {
1248           disable_thread_event_reporting (info);
1249
1250           /* Delete the old thread event breakpoints.  Note that
1251              unlike when mourning, we can remove them here because
1252              there's still a live inferior to poke at.  In any case,
1253              GDB will not try to insert anything in the inferior when
1254              removing a breakpoint.  */
1255           remove_thread_event_breakpoints ();
1256         }
1257
1258       delete_thread_db_info (GET_PID (inferior_ptid));
1259     }
1260
1261   target_beneath->to_detach (target_beneath, args, from_tty);
1262
1263   /* NOTE: From this point on, inferior_ptid is null_ptid.  */
1264
1265   /* If there are no more processes using libpthread, detach the
1266      thread_db target ops.  */
1267   if (!thread_db_list)
1268     unpush_target (&thread_db_ops);
1269 }
1270
1271 /* Check if PID is currently stopped at the location of a thread event
1272    breakpoint location.  If it is, read the event message and act upon
1273    the event.  */
1274
1275 static void
1276 check_event (ptid_t ptid)
1277 {
1278   struct regcache *regcache = get_thread_regcache (ptid);
1279   struct gdbarch *gdbarch = get_regcache_arch (regcache);
1280   td_event_msg_t msg;
1281   td_thrinfo_t ti;
1282   td_err_e err;
1283   CORE_ADDR stop_pc;
1284   int loop = 0;
1285   struct thread_db_info *info;
1286
1287   info = get_thread_db_info (GET_PID (ptid));
1288
1289   /* Bail out early if we're not at a thread event breakpoint.  */
1290   stop_pc = regcache_read_pc (regcache)
1291             - gdbarch_decr_pc_after_break (gdbarch);
1292   if (stop_pc != info->td_create_bp_addr
1293       && stop_pc != info->td_death_bp_addr)
1294     return;
1295
1296   /* Access an lwp we know is stopped.  */
1297   info->proc_handle.ptid = ptid;
1298
1299   /* If we have only looked at the first thread before libpthread was
1300      initialized, we may not know its thread ID yet.  Make sure we do
1301      before we add another thread to the list.  */
1302   if (!have_threads (ptid))
1303     thread_db_find_new_threads_1 (ptid);
1304
1305   /* If we are at a create breakpoint, we do not know what new lwp
1306      was created and cannot specifically locate the event message for it.
1307      We have to call td_ta_event_getmsg() to get
1308      the latest message.  Since we have no way of correlating whether
1309      the event message we get back corresponds to our breakpoint, we must
1310      loop and read all event messages, processing them appropriately.
1311      This guarantees we will process the correct message before continuing
1312      from the breakpoint.
1313
1314      Currently, death events are not enabled.  If they are enabled,
1315      the death event can use the td_thr_event_getmsg() interface to
1316      get the message specifically for that lwp and avoid looping
1317      below.  */
1318
1319   loop = 1;
1320
1321   do
1322     {
1323       err = info->td_ta_event_getmsg_p (info->thread_agent, &msg);
1324       if (err != TD_OK)
1325         {
1326           if (err == TD_NOMSG)
1327             return;
1328
1329           error (_("Cannot get thread event message: %s"),
1330                  thread_db_err_str (err));
1331         }
1332
1333       err = info->td_thr_get_info_p (msg.th_p, &ti);
1334       if (err != TD_OK)
1335         error (_("Cannot get thread info: %s"), thread_db_err_str (err));
1336
1337       ptid = ptid_build (GET_PID (ptid), ti.ti_lid, 0);
1338
1339       switch (msg.event)
1340         {
1341         case TD_CREATE:
1342           /* Call attach_thread whether or not we already know about a
1343              thread with this thread ID.  */
1344           attach_thread (ptid, msg.th_p, &ti);
1345
1346           break;
1347
1348         case TD_DEATH:
1349
1350           if (!in_thread_list (ptid))
1351             error (_("Spurious thread death event."));
1352
1353           detach_thread (ptid);
1354
1355           break;
1356
1357         default:
1358           error (_("Spurious thread event."));
1359         }
1360     }
1361   while (loop);
1362 }
1363
1364 static ptid_t
1365 thread_db_wait (struct target_ops *ops,
1366                 ptid_t ptid, struct target_waitstatus *ourstatus,
1367                 int options)
1368 {
1369   struct thread_db_info *info;
1370   struct target_ops *beneath = find_target_beneath (ops);
1371
1372   ptid = beneath->to_wait (beneath, ptid, ourstatus, options);
1373
1374   if (ourstatus->kind == TARGET_WAITKIND_IGNORE)
1375     return ptid;
1376
1377   if (ourstatus->kind == TARGET_WAITKIND_EXITED
1378       || ourstatus->kind == TARGET_WAITKIND_SIGNALLED)
1379     return ptid;
1380
1381   info = get_thread_db_info (GET_PID (ptid));
1382
1383   /* If this process isn't using thread_db, we're done.  */
1384   if (info == NULL)
1385     return ptid;
1386
1387   if (ourstatus->kind == TARGET_WAITKIND_EXECD)
1388     {
1389       /* New image, it may or may not end up using thread_db.  Assume
1390          not unless we find otherwise.  */
1391       delete_thread_db_info (GET_PID (ptid));
1392       if (!thread_db_list)
1393         unpush_target (&thread_db_ops);
1394
1395       /* Thread event breakpoints are deleted by
1396          update_breakpoints_after_exec.  */
1397
1398       return ptid;
1399     }
1400
1401   /* If we do not know about the main thread yet, this would be a good time to
1402      find it.  */
1403   if (ourstatus->kind == TARGET_WAITKIND_STOPPED && !have_threads (ptid))
1404     thread_db_find_new_threads_1 (ptid);
1405
1406   if (ourstatus->kind == TARGET_WAITKIND_STOPPED
1407       && ourstatus->value.sig == TARGET_SIGNAL_TRAP)
1408     /* Check for a thread event.  */
1409     check_event (ptid);
1410
1411   if (have_threads (ptid))
1412     {
1413       /* Change ptids back into the higher level PID + TID format.  If
1414          the thread is dead and no longer on the thread list, we will
1415          get back a dead ptid.  This can occur if the thread death
1416          event gets postponed by other simultaneous events.  In such a
1417          case, we want to just ignore the event and continue on.  */
1418
1419       ptid = thread_from_lwp (ptid);
1420       if (GET_PID (ptid) == -1)
1421         ourstatus->kind = TARGET_WAITKIND_SPURIOUS;
1422     }
1423
1424   return ptid;
1425 }
1426
1427 static void
1428 thread_db_mourn_inferior (struct target_ops *ops)
1429 {
1430   struct target_ops *target_beneath = find_target_beneath (ops);
1431
1432   delete_thread_db_info (GET_PID (inferior_ptid));
1433
1434   target_beneath->to_mourn_inferior (target_beneath);
1435
1436   /* Delete the old thread event breakpoints.  Do this after mourning
1437      the inferior, so that we don't try to uninsert them.  */
1438   remove_thread_event_breakpoints ();
1439
1440   /* Detach thread_db target ops.  */
1441   if (!thread_db_list)
1442     unpush_target (ops);
1443 }
1444
1445 struct callback_data
1446 {
1447   struct thread_db_info *info;
1448   int new_threads;
1449 };
1450
1451 static int
1452 find_new_threads_callback (const td_thrhandle_t *th_p, void *data)
1453 {
1454   td_thrinfo_t ti;
1455   td_err_e err;
1456   ptid_t ptid;
1457   struct thread_info *tp;
1458   struct callback_data *cb_data = data;
1459   struct thread_db_info *info = cb_data->info;
1460
1461   err = info->td_thr_get_info_p (th_p, &ti);
1462   if (err != TD_OK)
1463     error (_("find_new_threads_callback: cannot get thread info: %s"),
1464            thread_db_err_str (err));
1465
1466   if (ti.ti_state == TD_THR_UNKNOWN || ti.ti_state == TD_THR_ZOMBIE)
1467     return 0;                   /* A zombie -- ignore.  */
1468
1469   if (ti.ti_tid == 0)
1470     {
1471       /* A thread ID of zero means that this is the main thread, but
1472          glibc has not yet initialized thread-local storage and the
1473          pthread library.  We do not know what the thread's TID will
1474          be yet.  Just enable event reporting and otherwise ignore
1475          it.  */
1476
1477       /* In that case, we're not stopped in a fork syscall and don't
1478          need this glibc bug workaround.  */
1479       info->need_stale_parent_threads_check = 0;
1480
1481       if (target_has_execution)
1482         {
1483           err = info->td_thr_event_enable_p (th_p, 1);
1484           if (err != TD_OK)
1485             error (_("Cannot enable thread event reporting for LWP %d: %s"),
1486                    (int) ti.ti_lid, thread_db_err_str (err));
1487         }
1488
1489       return 0;
1490     }
1491
1492   /* Ignore stale parent threads, caused by glibc/BZ5983.  This is a
1493      bit expensive, as it needs to open /proc/pid/status, so try to
1494      avoid doing the work if we know we don't have to.  */
1495   if (info->need_stale_parent_threads_check)
1496     {
1497       int tgid = linux_proc_get_tgid (ti.ti_lid);
1498
1499       if (tgid != -1 && tgid != info->pid)
1500         return 0;
1501     }
1502
1503   ptid = ptid_build (info->pid, ti.ti_lid, 0);
1504   tp = find_thread_ptid (ptid);
1505   if (tp == NULL || tp->private == NULL)
1506     {
1507       if (attach_thread (ptid, th_p, &ti))
1508         cb_data->new_threads += 1;
1509       else
1510         /* Problem attaching this thread; perhaps it exited before we
1511            could attach it?
1512            This could mean that the thread list inside glibc itself is in
1513            inconsistent state, and libthread_db could go on looping forever
1514            (observed with glibc-2.3.6).  To prevent that, terminate
1515            iteration: thread_db_find_new_threads_2 will retry.  */
1516         return 1;
1517     }
1518
1519   return 0;
1520 }
1521
1522 /* Helper for thread_db_find_new_threads_2.
1523    Returns number of new threads found.  */
1524
1525 static int
1526 find_new_threads_once (struct thread_db_info *info, int iteration,
1527                        td_err_e *errp)
1528 {
1529   volatile struct gdb_exception except;
1530   struct callback_data data;
1531   td_err_e err = TD_ERR;
1532
1533   data.info = info;
1534   data.new_threads = 0;
1535
1536   TRY_CATCH (except, RETURN_MASK_ERROR)
1537     {
1538       /* Iterate over all user-space threads to discover new threads.  */
1539       err = info->td_ta_thr_iter_p (info->thread_agent,
1540                                     find_new_threads_callback,
1541                                     &data,
1542                                     TD_THR_ANY_STATE,
1543                                     TD_THR_LOWEST_PRIORITY,
1544                                     TD_SIGNO_MASK,
1545                                     TD_THR_ANY_USER_FLAGS);
1546     }
1547
1548   if (libthread_db_debug)
1549     {
1550       if (except.reason < 0)
1551         exception_fprintf (gdb_stderr, except,
1552                            "Warning: find_new_threads_once: ");
1553
1554       printf_filtered (_("Found %d new threads in iteration %d.\n"),
1555                        data.new_threads, iteration);
1556     }
1557
1558   if (errp != NULL)
1559     *errp = err;
1560
1561   return data.new_threads;
1562 }
1563
1564 /* Search for new threads, accessing memory through stopped thread
1565    PTID.  If UNTIL_NO_NEW is true, repeat searching until several
1566    searches in a row do not discover any new threads.  */
1567
1568 static void
1569 thread_db_find_new_threads_2 (ptid_t ptid, int until_no_new)
1570 {
1571   td_err_e err;
1572   struct thread_db_info *info;
1573   int pid = ptid_get_pid (ptid);
1574   int i, loop;
1575
1576   info = get_thread_db_info (GET_PID (ptid));
1577
1578   /* Access an lwp we know is stopped.  */
1579   info->proc_handle.ptid = ptid;
1580
1581   if (until_no_new)
1582     {
1583       /* Require 4 successive iterations which do not find any new threads.
1584          The 4 is a heuristic: there is an inherent race here, and I have
1585          seen that 2 iterations in a row are not always sufficient to
1586          "capture" all threads.  */
1587       for (i = 0, loop = 0; loop < 4; ++i, ++loop)
1588         if (find_new_threads_once (info, i, NULL) != 0)
1589           /* Found some new threads.  Restart the loop from beginning.  */
1590           loop = -1;
1591     }
1592   else
1593     {
1594       find_new_threads_once (info, 0, &err);
1595       if (err != TD_OK)
1596         error (_("Cannot find new threads: %s"), thread_db_err_str (err));
1597     }
1598 }
1599
1600 static void
1601 thread_db_find_new_threads_1 (ptid_t ptid)
1602 {
1603   thread_db_find_new_threads_2 (ptid, 0);
1604 }
1605
1606 static int
1607 update_thread_core (struct lwp_info *info, void *closure)
1608 {
1609   info->core = linux_nat_core_of_thread_1 (info->ptid);
1610   return 0;
1611 }
1612
1613 static void
1614 thread_db_find_new_threads (struct target_ops *ops)
1615 {
1616   struct thread_db_info *info;
1617   struct inferior *inf;
1618
1619   ALL_INFERIORS (inf)
1620     {
1621       struct thread_info *thread;
1622
1623       if (inf->pid == 0)
1624         continue;
1625
1626       info = get_thread_db_info (inf->pid);
1627       if (info == NULL)
1628         continue;
1629
1630       thread = any_live_thread_of_process (inf->pid);
1631       if (thread == NULL || thread->executing)
1632         continue;
1633
1634       thread_db_find_new_threads_1 (thread->ptid);
1635     }
1636
1637   if (target_has_execution)
1638     iterate_over_lwps (minus_one_ptid /* iterate over all */,
1639                        update_thread_core, NULL);
1640 }
1641
1642 static char *
1643 thread_db_pid_to_str (struct target_ops *ops, ptid_t ptid)
1644 {
1645   struct thread_info *thread_info = find_thread_ptid (ptid);
1646   struct target_ops *beneath;
1647
1648   if (thread_info != NULL && thread_info->private != NULL)
1649     {
1650       static char buf[64];
1651       thread_t tid;
1652
1653       tid = thread_info->private->tid;
1654       snprintf (buf, sizeof (buf), "Thread 0x%lx (LWP %ld)",
1655                 tid, GET_LWP (ptid));
1656
1657       return buf;
1658     }
1659
1660   beneath = find_target_beneath (ops);
1661   if (beneath->to_pid_to_str (beneath, ptid))
1662     return beneath->to_pid_to_str (beneath, ptid);
1663
1664   return normal_pid_to_str (ptid);
1665 }
1666
1667 /* Return a string describing the state of the thread specified by
1668    INFO.  */
1669
1670 static char *
1671 thread_db_extra_thread_info (struct thread_info *info)
1672 {
1673   if (info->private == NULL)
1674     return NULL;
1675
1676   if (info->private->dying)
1677     return "Exiting";
1678
1679   return NULL;
1680 }
1681
1682 /* Get the address of the thread local variable in load module LM which
1683    is stored at OFFSET within the thread local storage for thread PTID.  */
1684
1685 static CORE_ADDR
1686 thread_db_get_thread_local_address (struct target_ops *ops,
1687                                     ptid_t ptid,
1688                                     CORE_ADDR lm,
1689                                     CORE_ADDR offset)
1690 {
1691   struct thread_info *thread_info;
1692   struct target_ops *beneath;
1693
1694   /* If we have not discovered any threads yet, check now.  */
1695   if (!have_threads (ptid))
1696     thread_db_find_new_threads_1 (ptid);
1697
1698   /* Find the matching thread.  */
1699   thread_info = find_thread_ptid (ptid);
1700
1701   if (thread_info != NULL && thread_info->private != NULL)
1702     {
1703       td_err_e err;
1704       psaddr_t address;
1705       struct thread_db_info *info;
1706
1707       info = get_thread_db_info (GET_PID (ptid));
1708
1709       /* glibc doesn't provide the needed interface.  */
1710       if (!info->td_thr_tls_get_addr_p)
1711         throw_error (TLS_NO_LIBRARY_SUPPORT_ERROR,
1712                      _("No TLS library support"));
1713
1714       /* Caller should have verified that lm != 0.  */
1715       gdb_assert (lm != 0);
1716
1717       /* Finally, get the address of the variable.  */
1718       /* Note the cast through uintptr_t: this interface only works if
1719          a target address fits in a psaddr_t, which is a host pointer.
1720          So a 32-bit debugger can not access 64-bit TLS through this.  */
1721       err = info->td_thr_tls_get_addr_p (&thread_info->private->th,
1722                                          (psaddr_t)(uintptr_t) lm,
1723                                          offset, &address);
1724
1725 #ifdef THREAD_DB_HAS_TD_NOTALLOC
1726       /* The memory hasn't been allocated, yet.  */
1727       if (err == TD_NOTALLOC)
1728           /* Now, if libthread_db provided the initialization image's
1729              address, we *could* try to build a non-lvalue value from
1730              the initialization image.  */
1731         throw_error (TLS_NOT_ALLOCATED_YET_ERROR,
1732                      _("TLS not allocated yet"));
1733 #endif
1734
1735       /* Something else went wrong.  */
1736       if (err != TD_OK)
1737         throw_error (TLS_GENERIC_ERROR,
1738                      (("%s")), thread_db_err_str (err));
1739
1740       /* Cast assuming host == target.  Joy.  */
1741       /* Do proper sign extension for the target.  */
1742       gdb_assert (exec_bfd);
1743       return (bfd_get_sign_extend_vma (exec_bfd) > 0
1744               ? (CORE_ADDR) (intptr_t) address
1745               : (CORE_ADDR) (uintptr_t) address);
1746     }
1747
1748   beneath = find_target_beneath (ops);
1749   if (beneath->to_get_thread_local_address)
1750     return beneath->to_get_thread_local_address (beneath, ptid, lm, offset);
1751   else
1752     throw_error (TLS_GENERIC_ERROR,
1753                  _("TLS not supported on this target"));
1754 }
1755
1756 /* Callback routine used to find a thread based on the TID part of
1757    its PTID.  */
1758
1759 static int
1760 thread_db_find_thread_from_tid (struct thread_info *thread, void *data)
1761 {
1762   long *tid = (long *) data;
1763
1764   if (thread->private->tid == *tid)
1765     return 1;
1766
1767   return 0;
1768 }
1769
1770 /* Implement the to_get_ada_task_ptid target method for this target.  */
1771
1772 static ptid_t
1773 thread_db_get_ada_task_ptid (long lwp, long thread)
1774 {
1775   struct thread_info *thread_info;
1776
1777   thread_db_find_new_threads_1 (inferior_ptid);
1778   thread_info = iterate_over_threads (thread_db_find_thread_from_tid, &thread);
1779
1780   gdb_assert (thread_info != NULL);
1781
1782   return (thread_info->ptid);
1783 }
1784
1785 static void
1786 thread_db_resume (struct target_ops *ops,
1787                   ptid_t ptid, int step, enum target_signal signo)
1788 {
1789   struct target_ops *beneath = find_target_beneath (ops);
1790   struct thread_db_info *info;
1791
1792   if (ptid_equal (ptid, minus_one_ptid))
1793     info = get_thread_db_info (GET_PID (inferior_ptid));
1794   else
1795     info = get_thread_db_info (GET_PID (ptid));
1796
1797   /* This workaround is only needed for child fork lwps stopped in a
1798      PTRACE_O_TRACEFORK event.  When the inferior is resumed, the
1799      workaround can be disabled.  */
1800   if (info)
1801     info->need_stale_parent_threads_check = 0;
1802
1803   beneath->to_resume (beneath, ptid, step, signo);
1804 }
1805
1806 static void
1807 init_thread_db_ops (void)
1808 {
1809   thread_db_ops.to_shortname = "multi-thread";
1810   thread_db_ops.to_longname = "multi-threaded child process.";
1811   thread_db_ops.to_doc = "Threads and pthreads support.";
1812   thread_db_ops.to_detach = thread_db_detach;
1813   thread_db_ops.to_wait = thread_db_wait;
1814   thread_db_ops.to_resume = thread_db_resume;
1815   thread_db_ops.to_mourn_inferior = thread_db_mourn_inferior;
1816   thread_db_ops.to_find_new_threads = thread_db_find_new_threads;
1817   thread_db_ops.to_pid_to_str = thread_db_pid_to_str;
1818   thread_db_ops.to_stratum = thread_stratum;
1819   thread_db_ops.to_has_thread_control = tc_schedlock;
1820   thread_db_ops.to_get_thread_local_address
1821     = thread_db_get_thread_local_address;
1822   thread_db_ops.to_extra_thread_info = thread_db_extra_thread_info;
1823   thread_db_ops.to_get_ada_task_ptid = thread_db_get_ada_task_ptid;
1824   thread_db_ops.to_magic = OPS_MAGIC;
1825 }
1826
1827 /* Provide a prototype to silence -Wmissing-prototypes.  */
1828 extern initialize_file_ftype _initialize_thread_db;
1829
1830 void
1831 _initialize_thread_db (void)
1832 {
1833   init_thread_db_ops ();
1834   add_target (&thread_db_ops);
1835
1836   /* Defer loading of libthread_db.so until inferior is running.
1837      This allows gdb to load correct libthread_db for a given
1838      executable -- there could be mutiple versions of glibc,
1839      compiled with LinuxThreads or NPTL, and until there is
1840      a running inferior, we can't tell which libthread_db is
1841      the correct one to load.  */
1842
1843   libthread_db_search_path = xstrdup (LIBTHREAD_DB_SEARCH_PATH);
1844
1845   add_setshow_optional_filename_cmd ("libthread-db-search-path",
1846                                      class_support,
1847                                      &libthread_db_search_path, _("\
1848 Set search path for libthread_db."), _("\
1849 Show the current search path or libthread_db."), _("\
1850 This path is used to search for libthread_db to be loaded into \
1851 gdb itself.\n\
1852 Its value is a colon (':') separate list of directories to search.\n\
1853 Setting the search path to an empty list resets it to its default value."),
1854                             set_libthread_db_search_path,
1855                             NULL,
1856                             &setlist, &showlist);
1857
1858   add_setshow_zinteger_cmd ("libthread-db", class_maintenance,
1859                             &libthread_db_debug, _("\
1860 Set libthread-db debugging."), _("\
1861 Show libthread-db debugging."), _("\
1862 When non-zero, libthread-db debugging is enabled."),
1863                             NULL,
1864                             show_libthread_db_debug,
1865                             &setdebuglist, &showdebuglist);
1866
1867   /* Add ourselves to objfile event chain.  */
1868   observer_attach_new_objfile (thread_db_new_objfile);
1869
1870   /* Add ourselves to inferior_created event chain.
1871      This is needed to handle debugging statically linked programs where
1872      the new_objfile observer won't get called for libpthread.  */
1873   observer_attach_inferior_created (thread_db_inferior_created);
1874 }