OSDN Git Service

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