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