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