GNU/Linux: Stop using libthread_db/td_ta_thr_iter
[external/binutils.git] / gdb / gdbserver / thread-db.c
1 /* Thread management interface, for the remote server for GDB.
2    Copyright (C) 2002-2015 Free Software Foundation, Inc.
3
4    Contributed by MontaVista Software.
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 "server.h"
22
23 #include "linux-low.h"
24
25 extern int debug_threads;
26
27 static int thread_db_use_events;
28
29 #include "gdb_proc_service.h"
30 #include "nat/gdb_thread_db.h"
31 #include "gdb_vecs.h"
32 #include "nat/linux-procfs.h"
33
34 #ifndef USE_LIBTHREAD_DB_DIRECTLY
35 #include <dlfcn.h>
36 #endif
37
38 #include <stdint.h>
39 #include <limits.h>
40 #include <ctype.h>
41
42 struct thread_db
43 {
44   /* Structure that identifies the child process for the
45      <proc_service.h> interface.  */
46   struct ps_prochandle proc_handle;
47
48   /* Connection to the libthread_db library.  */
49   td_thragent_t *thread_agent;
50
51   /* If this flag has been set, we've already asked GDB for all
52      symbols we might need; assume symbol cache misses are
53      failures.  */
54   int all_symbols_looked_up;
55
56 #ifndef USE_LIBTHREAD_DB_DIRECTLY
57   /* Handle of the libthread_db from dlopen.  */
58   void *handle;
59 #endif
60
61   /* Thread creation event breakpoint.  The code at this location in
62      the child process will be called by the pthread library whenever
63      a new thread is created.  By setting a special breakpoint at this
64      location, GDB can detect when a new thread is created.  We obtain
65      this location via the td_ta_event_addr call.  Note that if the
66      running kernel supports tracing clones, then we don't need to use
67      (and in fact don't use) this magic thread event breakpoint to
68      learn about threads.  */
69   struct breakpoint *td_create_bp;
70
71   /* Addresses of libthread_db functions.  */
72   td_err_e (*td_ta_new_p) (struct ps_prochandle * ps, td_thragent_t **ta);
73   td_err_e (*td_ta_event_getmsg_p) (const td_thragent_t *ta,
74                                     td_event_msg_t *msg);
75   td_err_e (*td_ta_set_event_p) (const td_thragent_t *ta,
76                                  td_thr_events_t *event);
77   td_err_e (*td_ta_event_addr_p) (const td_thragent_t *ta,
78                                   td_event_e event, td_notify_t *ptr);
79   td_err_e (*td_ta_map_lwp2thr_p) (const td_thragent_t *ta, lwpid_t lwpid,
80                                    td_thrhandle_t *th);
81   td_err_e (*td_thr_get_info_p) (const td_thrhandle_t *th,
82                                  td_thrinfo_t *infop);
83   td_err_e (*td_thr_event_enable_p) (const td_thrhandle_t *th, int event);
84   td_err_e (*td_ta_thr_iter_p) (const td_thragent_t *ta,
85                                 td_thr_iter_f *callback, void *cbdata_p,
86                                 td_thr_state_e state, int ti_pri,
87                                 sigset_t *ti_sigmask_p,
88                                 unsigned int ti_user_flags);
89   td_err_e (*td_thr_tls_get_addr_p) (const td_thrhandle_t *th,
90                                      psaddr_t map_address,
91                                      size_t offset, psaddr_t *address);
92   td_err_e (*td_thr_tlsbase_p) (const td_thrhandle_t *th,
93                                 unsigned long int modid,
94                                 psaddr_t *base);
95   const char ** (*td_symbol_list_p) (void);
96 };
97
98 static char *libthread_db_search_path;
99
100 static int find_one_thread (ptid_t);
101 static int find_new_threads_callback (const td_thrhandle_t *th_p, void *data);
102
103 static const char *
104 thread_db_err_str (td_err_e err)
105 {
106   static char buf[64];
107
108   switch (err)
109     {
110     case TD_OK:
111       return "generic 'call succeeded'";
112     case TD_ERR:
113       return "generic error";
114     case TD_NOTHR:
115       return "no thread to satisfy query";
116     case TD_NOSV:
117       return "no sync handle to satisfy query";
118     case TD_NOLWP:
119       return "no LWP to satisfy query";
120     case TD_BADPH:
121       return "invalid process handle";
122     case TD_BADTH:
123       return "invalid thread handle";
124     case TD_BADSH:
125       return "invalid synchronization handle";
126     case TD_BADTA:
127       return "invalid thread agent";
128     case TD_BADKEY:
129       return "invalid key";
130     case TD_NOMSG:
131       return "no event message for getmsg";
132     case TD_NOFPREGS:
133       return "FPU register set not available";
134     case TD_NOLIBTHREAD:
135       return "application not linked with libthread";
136     case TD_NOEVENT:
137       return "requested event is not supported";
138     case TD_NOCAPAB:
139       return "capability not available";
140     case TD_DBERR:
141       return "debugger service failed";
142     case TD_NOAPLIC:
143       return "operation not applicable to";
144     case TD_NOTSD:
145       return "no thread-specific data for this thread";
146     case TD_MALLOC:
147       return "malloc failed";
148     case TD_PARTIALREG:
149       return "only part of register set was written/read";
150     case TD_NOXREGS:
151       return "X register set not available for this thread";
152 #ifdef HAVE_TD_VERSION
153     case TD_VERSION:
154       return "version mismatch between libthread_db and libpthread";
155 #endif
156     default:
157       xsnprintf (buf, sizeof (buf), "unknown thread_db error '%d'", err);
158       return buf;
159     }
160 }
161
162 #if 0
163 static char *
164 thread_db_state_str (td_thr_state_e state)
165 {
166   static char buf[64];
167
168   switch (state)
169     {
170     case TD_THR_STOPPED:
171       return "stopped by debugger";
172     case TD_THR_RUN:
173       return "runnable";
174     case TD_THR_ACTIVE:
175       return "active";
176     case TD_THR_ZOMBIE:
177       return "zombie";
178     case TD_THR_SLEEP:
179       return "sleeping";
180     case TD_THR_STOPPED_ASLEEP:
181       return "stopped by debugger AND blocked";
182     default:
183       xsnprintf (buf, sizeof (buf), "unknown thread_db state %d", state);
184       return buf;
185     }
186 }
187 #endif
188
189 static int
190 thread_db_create_event (CORE_ADDR where)
191 {
192   td_event_msg_t msg;
193   td_err_e err;
194   struct lwp_info *lwp;
195   struct thread_db *thread_db = current_process ()->private->thread_db;
196
197   gdb_assert (thread_db->td_ta_event_getmsg_p != NULL);
198
199   if (debug_threads)
200     debug_printf ("Thread creation event.\n");
201
202   /* FIXME: This assumes we don't get another event.
203      In the LinuxThreads implementation, this is safe,
204      because all events come from the manager thread
205      (except for its own creation, of course).  */
206   err = thread_db->td_ta_event_getmsg_p (thread_db->thread_agent, &msg);
207   if (err != TD_OK)
208     fprintf (stderr, "thread getmsg err: %s\n",
209              thread_db_err_str (err));
210
211   /* If we do not know about the main thread yet, this would be a good time to
212      find it.  We need to do this to pick up the main thread before any newly
213      created threads.  */
214   lwp = get_thread_lwp (current_thread);
215   if (lwp->thread_known == 0)
216     find_one_thread (current_thread->entry.id);
217
218   /* msg.event == TD_EVENT_CREATE */
219
220   find_new_threads_callback (msg.th_p, NULL);
221
222   return 0;
223 }
224
225 static int
226 thread_db_enable_reporting (void)
227 {
228   td_thr_events_t events;
229   td_notify_t notify;
230   td_err_e err;
231   struct thread_db *thread_db = current_process ()->private->thread_db;
232
233   if (thread_db->td_ta_set_event_p == NULL
234       || thread_db->td_ta_event_addr_p == NULL
235       || thread_db->td_ta_event_getmsg_p == NULL)
236     /* This libthread_db is missing required support.  */
237     return 0;
238
239   /* Set the process wide mask saying which events we're interested in.  */
240   td_event_emptyset (&events);
241   td_event_addset (&events, TD_CREATE);
242
243   err = thread_db->td_ta_set_event_p (thread_db->thread_agent, &events);
244   if (err != TD_OK)
245     {
246       warning ("Unable to set global thread event mask: %s",
247                thread_db_err_str (err));
248       return 0;
249     }
250
251   /* Get address for thread creation breakpoint.  */
252   err = thread_db->td_ta_event_addr_p (thread_db->thread_agent, TD_CREATE,
253                                        &notify);
254   if (err != TD_OK)
255     {
256       warning ("Unable to get location for thread creation breakpoint: %s",
257                thread_db_err_str (err));
258       return 0;
259     }
260   thread_db->td_create_bp
261     = set_breakpoint_at ((CORE_ADDR) (unsigned long) notify.u.bptaddr,
262                          thread_db_create_event);
263
264   return 1;
265 }
266
267 static int
268 find_one_thread (ptid_t ptid)
269 {
270   td_thrhandle_t th;
271   td_thrinfo_t ti;
272   td_err_e err;
273   struct thread_info *inferior;
274   struct lwp_info *lwp;
275   struct thread_db *thread_db = current_process ()->private->thread_db;
276   int lwpid = ptid_get_lwp (ptid);
277
278   inferior = (struct thread_info *) find_inferior_id (&all_threads, ptid);
279   lwp = get_thread_lwp (inferior);
280   if (lwp->thread_known)
281     return 1;
282
283   /* Get information about this thread.  */
284   err = thread_db->td_ta_map_lwp2thr_p (thread_db->thread_agent, lwpid, &th);
285   if (err != TD_OK)
286     error ("Cannot get thread handle for LWP %d: %s",
287            lwpid, thread_db_err_str (err));
288
289   err = thread_db->td_thr_get_info_p (&th, &ti);
290   if (err != TD_OK)
291     error ("Cannot get thread info for LWP %d: %s",
292            lwpid, thread_db_err_str (err));
293
294   if (debug_threads)
295     debug_printf ("Found thread %ld (LWP %d)\n",
296                   ti.ti_tid, ti.ti_lid);
297
298   if (lwpid != ti.ti_lid)
299     {
300       warning ("PID mismatch!  Expected %ld, got %ld",
301                (long) lwpid, (long) ti.ti_lid);
302       return 0;
303     }
304
305   if (thread_db_use_events)
306     {
307       err = thread_db->td_thr_event_enable_p (&th, 1);
308       if (err != TD_OK)
309         error ("Cannot enable thread event reporting for %d: %s",
310                ti.ti_lid, thread_db_err_str (err));
311     }
312
313   /* If the new thread ID is zero, a final thread ID will be available
314      later.  Do not enable thread debugging yet.  */
315   if (ti.ti_tid == 0)
316     return 0;
317
318   lwp->thread_known = 1;
319   lwp->th = th;
320
321   return 1;
322 }
323
324 /* Attach a thread.  Return true on success.  */
325
326 static int
327 attach_thread (const td_thrhandle_t *th_p, td_thrinfo_t *ti_p)
328 {
329   struct process_info *proc = current_process ();
330   int pid = pid_of (proc);
331   ptid_t ptid = ptid_build (pid, ti_p->ti_lid, 0);
332   struct lwp_info *lwp;
333   int err;
334
335   if (debug_threads)
336     debug_printf ("Attaching to thread %ld (LWP %d)\n",
337                   ti_p->ti_tid, ti_p->ti_lid);
338   err = linux_attach_lwp (ptid);
339   if (err != 0)
340     {
341       warning ("Could not attach to thread %ld (LWP %d): %s\n",
342                ti_p->ti_tid, ti_p->ti_lid,
343                linux_ptrace_attach_fail_reason_string (ptid, err));
344       return 0;
345     }
346
347   lwp = find_lwp_pid (ptid);
348   gdb_assert (lwp != NULL);
349   lwp->thread_known = 1;
350   lwp->th = *th_p;
351
352   if (thread_db_use_events)
353     {
354       td_err_e err;
355       struct thread_db *thread_db = proc->private->thread_db;
356
357       err = thread_db->td_thr_event_enable_p (th_p, 1);
358       if (err != TD_OK)
359         error ("Cannot enable thread event reporting for %d: %s",
360                ti_p->ti_lid, thread_db_err_str (err));
361     }
362
363   return 1;
364 }
365
366 /* Attach thread if we haven't seen it yet.
367    Increment *COUNTER if we have attached a new thread.
368    Return false on failure.  */
369
370 static int
371 maybe_attach_thread (const td_thrhandle_t *th_p, td_thrinfo_t *ti_p,
372                      int *counter)
373 {
374   struct lwp_info *lwp;
375
376   lwp = find_lwp_pid (pid_to_ptid (ti_p->ti_lid));
377   if (lwp != NULL)
378     return 1;
379
380   if (!attach_thread (th_p, ti_p))
381     return 0;
382
383   if (counter != NULL)
384     *counter += 1;
385
386   return 1;
387 }
388
389 static int
390 find_new_threads_callback (const td_thrhandle_t *th_p, void *data)
391 {
392   td_thrinfo_t ti;
393   td_err_e err;
394   struct thread_db *thread_db = current_process ()->private->thread_db;
395
396   err = thread_db->td_thr_get_info_p (th_p, &ti);
397   if (err != TD_OK)
398     error ("Cannot get thread info: %s", thread_db_err_str (err));
399
400   if (ti.ti_lid == -1)
401     {
402       /* A thread with kernel thread ID -1 is either a thread that
403          exited and was joined, or a thread that is being created but
404          hasn't started yet, and that is reusing the tcb/stack of a
405          thread that previously exited and was joined.  (glibc marks
406          terminated and joined threads with kernel thread ID -1.  See
407          glibc PR17707.  */
408       if (debug_threads)
409         debug_printf ("thread_db: skipping exited and "
410                       "joined thread (0x%lx)\n", ti.ti_tid);
411       return 0;
412     }
413
414   /* Check for zombies.  */
415   if (ti.ti_state == TD_THR_UNKNOWN || ti.ti_state == TD_THR_ZOMBIE)
416     return 0;
417
418   if (!maybe_attach_thread (th_p, &ti, (int *) data))
419     {
420       /* Terminate iteration early: we might be looking at stale data in
421          the inferior.  The thread_db_find_new_threads will retry.  */
422       return 1;
423     }
424
425   return 0;
426 }
427
428 static void
429 thread_db_find_new_threads (void)
430 {
431   td_err_e err;
432   ptid_t ptid = current_ptid;
433   struct thread_db *thread_db = current_process ()->private->thread_db;
434   int loop, iteration;
435
436   /* This function is only called when we first initialize thread_db.
437      First locate the initial thread.  If it is not ready for
438      debugging yet, then stop.  */
439   if (find_one_thread (ptid) == 0)
440     return;
441
442   /* Require 4 successive iterations which do not find any new threads.
443      The 4 is a heuristic: there is an inherent race here, and I have
444      seen that 2 iterations in a row are not always sufficient to
445      "capture" all threads.  */
446   for (loop = 0, iteration = 0; loop < 4; ++loop, ++iteration)
447     {
448       int new_thread_count = 0;
449
450       /* Iterate over all user-space threads to discover new threads.  */
451       err = thread_db->td_ta_thr_iter_p (thread_db->thread_agent,
452                                          find_new_threads_callback,
453                                          &new_thread_count,
454                                          TD_THR_ANY_STATE,
455                                          TD_THR_LOWEST_PRIORITY,
456                                          TD_SIGNO_MASK, TD_THR_ANY_USER_FLAGS);
457       if (debug_threads)
458         debug_printf ("Found %d threads in iteration %d.\n",
459                       new_thread_count, iteration);
460
461       if (new_thread_count != 0)
462         {
463           /* Found new threads.  Restart iteration from beginning.  */
464           loop = -1;
465         }
466     }
467   if (err != TD_OK)
468     error ("Cannot find new threads: %s", thread_db_err_str (err));
469 }
470
471 /* Cache all future symbols that thread_db might request.  We can not
472    request symbols at arbitrary states in the remote protocol, only
473    when the client tells us that new symbols are available.  So when
474    we load the thread library, make sure to check the entire list.  */
475
476 static void
477 thread_db_look_up_symbols (void)
478 {
479   struct thread_db *thread_db = current_process ()->private->thread_db;
480   const char **sym_list;
481   CORE_ADDR unused;
482
483   for (sym_list = thread_db->td_symbol_list_p (); *sym_list; sym_list++)
484     look_up_one_symbol (*sym_list, &unused, 1);
485
486   /* We're not interested in any other libraries loaded after this
487      point, only in symbols in libpthread.so.  */
488   thread_db->all_symbols_looked_up = 1;
489 }
490
491 int
492 thread_db_look_up_one_symbol (const char *name, CORE_ADDR *addrp)
493 {
494   struct thread_db *thread_db = current_process ()->private->thread_db;
495   int may_ask_gdb = !thread_db->all_symbols_looked_up;
496
497   /* If we've passed the call to thread_db_look_up_symbols, then
498      anything not in the cache must not exist; we're not interested
499      in any libraries loaded after that point, only in symbols in
500      libpthread.so.  It might not be an appropriate time to look
501      up a symbol, e.g. while we're trying to fetch registers.  */
502   return look_up_one_symbol (name, addrp, may_ask_gdb);
503 }
504
505 int
506 thread_db_get_tls_address (struct thread_info *thread, CORE_ADDR offset,
507                            CORE_ADDR load_module, CORE_ADDR *address)
508 {
509   psaddr_t addr;
510   td_err_e err;
511   struct lwp_info *lwp;
512   struct thread_info *saved_thread;
513   struct process_info *proc;
514   struct thread_db *thread_db;
515
516   proc = get_thread_process (thread);
517   thread_db = proc->private->thread_db;
518
519   /* If the thread layer is not (yet) initialized, fail.  */
520   if (thread_db == NULL || !thread_db->all_symbols_looked_up)
521     return TD_ERR;
522
523   /* If td_thr_tls_get_addr is missing rather do not expect td_thr_tlsbase
524      could work.  */
525   if (thread_db->td_thr_tls_get_addr_p == NULL
526       || (load_module == 0 && thread_db->td_thr_tlsbase_p == NULL))
527     return -1;
528
529   lwp = get_thread_lwp (thread);
530   if (!lwp->thread_known)
531     find_one_thread (thread->entry.id);
532   if (!lwp->thread_known)
533     return TD_NOTHR;
534
535   saved_thread = current_thread;
536   current_thread = thread;
537
538   if (load_module != 0)
539     {
540       /* Note the cast through uintptr_t: this interface only works if
541          a target address fits in a psaddr_t, which is a host pointer.
542          So a 32-bit debugger can not access 64-bit TLS through this.  */
543       err = thread_db->td_thr_tls_get_addr_p (&lwp->th,
544                                              (psaddr_t) (uintptr_t) load_module,
545                                               offset, &addr);
546     }
547   else
548     {
549       /* This code path handles the case of -static -pthread executables:
550          https://sourceware.org/ml/libc-help/2014-03/msg00024.html
551          For older GNU libc r_debug.r_map is NULL.  For GNU libc after
552          PR libc/16831 due to GDB PR threads/16954 LOAD_MODULE is also NULL.
553          The constant number 1 depends on GNU __libc_setup_tls
554          initialization of l_tls_modid to 1.  */
555       err = thread_db->td_thr_tlsbase_p (&lwp->th, 1, &addr);
556       addr = (char *) addr + offset;
557     }
558
559   current_thread = saved_thread;
560   if (err == TD_OK)
561     {
562       *address = (CORE_ADDR) (uintptr_t) addr;
563       return 0;
564     }
565   else
566     return err;
567 }
568
569 #ifdef USE_LIBTHREAD_DB_DIRECTLY
570
571 static int
572 thread_db_load_search (void)
573 {
574   td_err_e err;
575   struct thread_db *tdb;
576   struct process_info *proc = current_process ();
577
578   gdb_assert (proc->private->thread_db == NULL);
579
580   tdb = xcalloc (1, sizeof (*tdb));
581   proc->private->thread_db = tdb;
582
583   tdb->td_ta_new_p = &td_ta_new;
584
585   /* Attempt to open a connection to the thread library.  */
586   err = tdb->td_ta_new_p (&tdb->proc_handle, &tdb->thread_agent);
587   if (err != TD_OK)
588     {
589       if (debug_threads)
590         debug_printf ("td_ta_new(): %s\n", thread_db_err_str (err));
591       free (tdb);
592       proc->private->thread_db = NULL;
593       return 0;
594     }
595
596   tdb->td_ta_map_lwp2thr_p = &td_ta_map_lwp2thr;
597   tdb->td_thr_get_info_p = &td_thr_get_info;
598   tdb->td_ta_thr_iter_p = &td_ta_thr_iter;
599   tdb->td_symbol_list_p = &td_symbol_list;
600
601   /* This is required only when thread_db_use_events is on.  */
602   tdb->td_thr_event_enable_p = &td_thr_event_enable;
603
604   /* These are not essential.  */
605   tdb->td_ta_event_addr_p = &td_ta_event_addr;
606   tdb->td_ta_set_event_p = &td_ta_set_event;
607   tdb->td_ta_event_getmsg_p = &td_ta_event_getmsg;
608   tdb->td_thr_tls_get_addr_p = &td_thr_tls_get_addr;
609   tdb->td_thr_tlsbase_p = &td_thr_tlsbase;
610
611   return 1;
612 }
613
614 #else
615
616 static int
617 try_thread_db_load_1 (void *handle)
618 {
619   td_err_e err;
620   struct thread_db *tdb;
621   struct process_info *proc = current_process ();
622
623   gdb_assert (proc->private->thread_db == NULL);
624
625   tdb = xcalloc (1, sizeof (*tdb));
626   proc->private->thread_db = tdb;
627
628   tdb->handle = handle;
629
630   /* Initialize pointers to the dynamic library functions we will use.
631      Essential functions first.  */
632
633 #define CHK(required, a)                                        \
634   do                                                            \
635     {                                                           \
636       if ((a) == NULL)                                          \
637         {                                                       \
638           if (debug_threads)                                    \
639             debug_printf ("dlsym: %s\n", dlerror ());           \
640           if (required)                                         \
641             {                                                   \
642               free (tdb);                                       \
643               proc->private->thread_db = NULL;                  \
644               return 0;                                         \
645             }                                                   \
646         }                                                       \
647     }                                                           \
648   while (0)
649
650   CHK (1, tdb->td_ta_new_p = dlsym (handle, "td_ta_new"));
651
652   /* Attempt to open a connection to the thread library.  */
653   err = tdb->td_ta_new_p (&tdb->proc_handle, &tdb->thread_agent);
654   if (err != TD_OK)
655     {
656       if (debug_threads)
657         debug_printf ("td_ta_new(): %s\n", thread_db_err_str (err));
658       free (tdb);
659       proc->private->thread_db = NULL;
660       return 0;
661     }
662
663   CHK (1, tdb->td_ta_map_lwp2thr_p = dlsym (handle, "td_ta_map_lwp2thr"));
664   CHK (1, tdb->td_thr_get_info_p = dlsym (handle, "td_thr_get_info"));
665   CHK (1, tdb->td_ta_thr_iter_p = dlsym (handle, "td_ta_thr_iter"));
666   CHK (1, tdb->td_symbol_list_p = dlsym (handle, "td_symbol_list"));
667
668   /* This is required only when thread_db_use_events is on.  */
669   CHK (thread_db_use_events,
670        tdb->td_thr_event_enable_p = dlsym (handle, "td_thr_event_enable"));
671
672   /* These are not essential.  */
673   CHK (0, tdb->td_ta_event_addr_p = dlsym (handle, "td_ta_event_addr"));
674   CHK (0, tdb->td_ta_set_event_p = dlsym (handle, "td_ta_set_event"));
675   CHK (0, tdb->td_ta_event_getmsg_p = dlsym (handle, "td_ta_event_getmsg"));
676   CHK (0, tdb->td_thr_tls_get_addr_p = dlsym (handle, "td_thr_tls_get_addr"));
677   CHK (0, tdb->td_thr_tlsbase_p = dlsym (handle, "td_thr_tlsbase"));
678
679 #undef CHK
680
681   return 1;
682 }
683
684 #ifdef HAVE_DLADDR
685
686 /* Lookup a library in which given symbol resides.
687    Note: this is looking in the GDBSERVER process, not in the inferior.
688    Returns library name, or NULL.  */
689
690 static const char *
691 dladdr_to_soname (const void *addr)
692 {
693   Dl_info info;
694
695   if (dladdr (addr, &info) != 0)
696     return info.dli_fname;
697   return NULL;
698 }
699
700 #endif
701
702 static int
703 try_thread_db_load (const char *library)
704 {
705   void *handle;
706
707   if (debug_threads)
708     debug_printf ("Trying host libthread_db library: %s.\n",
709                   library);
710   handle = dlopen (library, RTLD_NOW);
711   if (handle == NULL)
712     {
713       if (debug_threads)
714         debug_printf ("dlopen failed: %s.\n", dlerror ());
715       return 0;
716     }
717
718 #ifdef HAVE_DLADDR
719   if (debug_threads && strchr (library, '/') == NULL)
720     {
721       void *td_init;
722
723       td_init = dlsym (handle, "td_init");
724       if (td_init != NULL)
725         {
726           const char *const libpath = dladdr_to_soname (td_init);
727
728           if (libpath != NULL)
729             fprintf (stderr, "Host %s resolved to: %s.\n",
730                      library, libpath);
731         }
732     }
733 #endif
734
735   if (try_thread_db_load_1 (handle))
736     return 1;
737
738   /* This library "refused" to work on current inferior.  */
739   dlclose (handle);
740   return 0;
741 }
742
743 /* Handle $sdir in libthread-db-search-path.
744    Look for libthread_db in the system dirs, or wherever a plain
745    dlopen(file_without_path) will look.
746    The result is true for success.  */
747
748 static int
749 try_thread_db_load_from_sdir (void)
750 {
751   return try_thread_db_load (LIBTHREAD_DB_SO);
752 }
753
754 /* Try to load libthread_db from directory DIR of length DIR_LEN.
755    The result is true for success.  */
756
757 static int
758 try_thread_db_load_from_dir (const char *dir, size_t dir_len)
759 {
760   char path[PATH_MAX];
761
762   if (dir_len + 1 + strlen (LIBTHREAD_DB_SO) + 1 > sizeof (path))
763     {
764       char *cp = xmalloc (dir_len + 1);
765
766       memcpy (cp, dir, dir_len);
767       cp[dir_len] = '\0';
768       warning (_("libthread-db-search-path component too long,"
769                  " ignored: %s."), cp);
770       free (cp);
771       return 0;
772     }
773
774   memcpy (path, dir, dir_len);
775   path[dir_len] = '/';
776   strcpy (path + dir_len + 1, LIBTHREAD_DB_SO);
777   return try_thread_db_load (path);
778 }
779
780 /* Search libthread_db_search_path for libthread_db which "agrees"
781    to work on current inferior.
782    The result is true for success.  */
783
784 static int
785 thread_db_load_search (void)
786 {
787   VEC (char_ptr) *dir_vec;
788   char *this_dir;
789   int i, rc = 0;
790
791   if (libthread_db_search_path == NULL)
792     libthread_db_search_path = xstrdup (LIBTHREAD_DB_SEARCH_PATH);
793
794   dir_vec = dirnames_to_char_ptr_vec (libthread_db_search_path);
795
796   for (i = 0; VEC_iterate (char_ptr, dir_vec, i, this_dir); ++i)
797     {
798       const int pdir_len = sizeof ("$pdir") - 1;
799       size_t this_dir_len;
800
801       this_dir_len = strlen (this_dir);
802
803       if (strncmp (this_dir, "$pdir", pdir_len) == 0
804           && (this_dir[pdir_len] == '\0'
805               || this_dir[pdir_len] == '/'))
806         {
807           /* We don't maintain a list of loaded libraries so we don't know
808              where libpthread lives.  We *could* fetch the info, but we don't
809              do that yet.  Ignore it.  */
810         }
811       else if (strcmp (this_dir, "$sdir") == 0)
812         {
813           if (try_thread_db_load_from_sdir ())
814             {
815               rc = 1;
816               break;
817             }
818         }
819       else
820         {
821           if (try_thread_db_load_from_dir (this_dir, this_dir_len))
822             {
823               rc = 1;
824               break;
825             }
826         }
827     }
828
829   free_char_ptr_vec (dir_vec);
830   if (debug_threads)
831     debug_printf ("thread_db_load_search returning %d\n", rc);
832   return rc;
833 }
834
835 #endif  /* USE_LIBTHREAD_DB_DIRECTLY */
836
837 int
838 thread_db_init (int use_events)
839 {
840   struct process_info *proc = current_process ();
841
842   /* FIXME drow/2004-10-16: This is the "overall process ID", which
843      GNU/Linux calls tgid, "thread group ID".  When we support
844      attaching to threads, the original thread may not be the correct
845      thread.  We would have to get the process ID from /proc for NPTL.
846      For LinuxThreads we could do something similar: follow the chain
847      of parent processes until we find the highest one we're attached
848      to, and use its tgid.
849
850      This isn't the only place in gdbserver that assumes that the first
851      process in the list is the thread group leader.  */
852
853   thread_db_use_events = use_events;
854
855   if (thread_db_load_search ())
856     {
857       if (use_events && thread_db_enable_reporting () == 0)
858         {
859           /* Keep trying; maybe event reporting will work later.  */
860           thread_db_mourn (proc);
861           return 0;
862         }
863
864       /* It's best to avoid td_ta_thr_iter if possible.  That walks
865          data structures in the inferior's address space that may be
866          corrupted, or, if the target is running, the list may change
867          while we walk it.  In the latter case, it's possible that a
868          thread exits just at the exact time that causes GDBserver to
869          get stuck in an infinite loop.  If the kernel supports clone
870          events, and /proc/PID/task/ exits, then we already know about
871          all threads in the process.  When we need info out of
872          thread_db on a given thread (e.g., for TLS), we'll use
873          find_one_thread then.  That uses thread_db entry points that
874          do not walk libpthread's thread list, so should be safe, as
875          well as more efficient.  */
876       if (use_events
877           || !linux_proc_task_list_dir_exists (pid_of (proc)))
878         thread_db_find_new_threads ();
879       thread_db_look_up_symbols ();
880       return 1;
881     }
882
883   return 0;
884 }
885
886 static int
887 any_thread_of (struct inferior_list_entry *entry, void *args)
888 {
889   int *pid_p = args;
890
891   if (ptid_get_pid (entry->id) == *pid_p)
892     return 1;
893
894   return 0;
895 }
896
897 static void
898 switch_to_process (struct process_info *proc)
899 {
900   int pid = pid_of (proc);
901
902   current_thread =
903     (struct thread_info *) find_inferior (&all_threads,
904                                           any_thread_of, &pid);
905 }
906
907 /* Disconnect from libthread_db and free resources.  */
908
909 static void
910 disable_thread_event_reporting (struct process_info *proc)
911 {
912   struct thread_db *thread_db = proc->private->thread_db;
913   if (thread_db)
914     {
915       td_err_e (*td_ta_clear_event_p) (const td_thragent_t *ta,
916                                        td_thr_events_t *event);
917
918 #ifndef USE_LIBTHREAD_DB_DIRECTLY
919       td_ta_clear_event_p = dlsym (thread_db->handle, "td_ta_clear_event");
920 #else
921       td_ta_clear_event_p = &td_ta_clear_event;
922 #endif
923
924       if (td_ta_clear_event_p != NULL)
925         {
926           struct thread_info *saved_thread = current_thread;
927           td_thr_events_t events;
928
929           switch_to_process (proc);
930
931           /* Set the process wide mask saying we aren't interested
932              in any events anymore.  */
933           td_event_fillset (&events);
934           (*td_ta_clear_event_p) (thread_db->thread_agent, &events);
935
936           current_thread = saved_thread;
937         }
938     }
939 }
940
941 static void
942 remove_thread_event_breakpoints (struct process_info *proc)
943 {
944   struct thread_db *thread_db = proc->private->thread_db;
945
946   if (thread_db->td_create_bp != NULL)
947     {
948       struct thread_info *saved_thread = current_thread;
949
950       switch_to_process (proc);
951
952       delete_breakpoint (thread_db->td_create_bp);
953       thread_db->td_create_bp = NULL;
954
955       current_thread = saved_thread;
956     }
957 }
958
959 void
960 thread_db_detach (struct process_info *proc)
961 {
962   struct thread_db *thread_db = proc->private->thread_db;
963
964   if (thread_db)
965     {
966       disable_thread_event_reporting (proc);
967       remove_thread_event_breakpoints (proc);
968     }
969 }
970
971 /* Disconnect from libthread_db and free resources.  */
972
973 void
974 thread_db_mourn (struct process_info *proc)
975 {
976   struct thread_db *thread_db = proc->private->thread_db;
977   if (thread_db)
978     {
979       td_err_e (*td_ta_delete_p) (td_thragent_t *);
980
981 #ifndef USE_LIBTHREAD_DB_DIRECTLY
982       td_ta_delete_p = dlsym (thread_db->handle, "td_ta_delete");
983 #else
984       td_ta_delete_p = &td_ta_delete;
985 #endif
986
987       if (td_ta_delete_p != NULL)
988         (*td_ta_delete_p) (thread_db->thread_agent);
989
990 #ifndef USE_LIBTHREAD_DB_DIRECTLY
991       dlclose (thread_db->handle);
992 #endif  /* USE_LIBTHREAD_DB_DIRECTLY  */
993
994       free (thread_db);
995       proc->private->thread_db = NULL;
996     }
997 }
998
999 /* Handle "set libthread-db-search-path" monitor command and return 1.
1000    For any other command, return 0.  */
1001
1002 int
1003 thread_db_handle_monitor_command (char *mon)
1004 {
1005   const char *cmd = "set libthread-db-search-path";
1006   size_t cmd_len = strlen (cmd);
1007
1008   if (strncmp (mon, cmd, cmd_len) == 0
1009       && (mon[cmd_len] == '\0'
1010           || mon[cmd_len] == ' '))
1011     {
1012       const char *cp = mon + cmd_len;
1013
1014       if (libthread_db_search_path != NULL)
1015         free (libthread_db_search_path);
1016
1017       /* Skip leading space (if any).  */
1018       while (isspace (*cp))
1019         ++cp;
1020
1021       if (*cp == '\0')
1022         cp = LIBTHREAD_DB_SEARCH_PATH;
1023       libthread_db_search_path = xstrdup (cp);
1024
1025       monitor_output ("libthread-db-search-path set to `");
1026       monitor_output (libthread_db_search_path);
1027       monitor_output ("'\n");
1028       return 1;
1029     }
1030
1031   /* Tell server.c to perform default processing.  */
1032   return 0;
1033 }