Change TUI source window iteration
[external/binutils.git] / gdb / linux-thread-db.c
1 /* libthread_db assisted debugging support, generic parts.
2
3    Copyright (C) 1999-2019 Free Software Foundation, Inc.
4
5    This file is part of GDB.
6
7    This program is free software; you can redistribute it and/or modify
8    it under the terms of the GNU General Public License as published by
9    the Free Software Foundation; either version 3 of the License, or
10    (at your option) any later version.
11
12    This program is distributed in the hope that it will be useful,
13    but WITHOUT ANY WARRANTY; without even the implied warranty of
14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15    GNU General Public License for more details.
16
17    You should have received a copy of the GNU General Public License
18    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
19
20 #include "defs.h"
21 #include <dlfcn.h>
22 #include "gdb_proc_service.h"
23 #include "nat/gdb_thread_db.h"
24 #include "gdbsupport/gdb_vecs.h"
25 #include "bfd.h"
26 #include "command.h"
27 #include "gdbcmd.h"
28 #include "gdbthread.h"
29 #include "inferior.h"
30 #include "infrun.h"
31 #include "symfile.h"
32 #include "objfiles.h"
33 #include "target.h"
34 #include "regcache.h"
35 #include "solib.h"
36 #include "solib-svr4.h"
37 #include "gdbcore.h"
38 #include "observable.h"
39 #include "linux-nat.h"
40 #include "nat/linux-procfs.h"
41 #include "nat/linux-ptrace.h"
42 #include "nat/linux-osdata.h"
43 #include "auto-load.h"
44 #include "cli/cli-utils.h"
45 #include <signal.h>
46 #include <ctype.h>
47 #include "nat/linux-namespaces.h"
48 #include <algorithm>
49 #include "gdbsupport/pathstuff.h"
50 #include "valprint.h"
51
52 /* GNU/Linux libthread_db support.
53
54    libthread_db is a library, provided along with libpthread.so, which
55    exposes the internals of the thread library to a debugger.  It
56    allows GDB to find existing threads, new threads as they are
57    created, thread IDs (usually, the result of pthread_self), and
58    thread-local variables.
59
60    The libthread_db interface originates on Solaris, where it is both
61    more powerful and more complicated.  This implementation only works
62    for NPTL, the glibc threading library.  It assumes that each thread
63    is permanently assigned to a single light-weight process (LWP).  At
64    some point it also supported the older LinuxThreads library, but it
65    no longer does.
66
67    libthread_db-specific information is stored in the "private" field
68    of struct thread_info.  When the field is NULL we do not yet have
69    information about the new thread; this could be temporary (created,
70    but the thread library's data structures do not reflect it yet)
71    or permanent (created using clone instead of pthread_create).
72
73    Process IDs managed by linux-thread-db.c match those used by
74    linux-nat.c: a common PID for all processes, an LWP ID for each
75    thread, and no TID.  We save the TID in private.  Keeping it out
76    of the ptid_t prevents thread IDs changing when libpthread is
77    loaded or unloaded.  */
78
79 static const target_info thread_db_target_info = {
80   "multi-thread",
81   N_("multi-threaded child process."),
82   N_("Threads and pthreads support.")
83 };
84
85 class thread_db_target final : public target_ops
86 {
87 public:
88   const target_info &info () const override
89   { return thread_db_target_info; }
90
91   strata stratum () const override { return thread_stratum; }
92
93   void detach (inferior *, int) override;
94   ptid_t wait (ptid_t, struct target_waitstatus *, int) override;
95   void resume (ptid_t, int, enum gdb_signal) override;
96   void mourn_inferior () override;
97   void update_thread_list () override;
98   std::string pid_to_str (ptid_t) override;
99   CORE_ADDR get_thread_local_address (ptid_t ptid,
100                                       CORE_ADDR load_module_addr,
101                                       CORE_ADDR offset) override;
102   const char *extra_thread_info (struct thread_info *) override;
103   ptid_t get_ada_task_ptid (long lwp, long thread) override;
104
105   thread_info *thread_handle_to_thread_info (const gdb_byte *thread_handle,
106                                              int handle_len,
107                                              inferior *inf) override;
108   gdb::byte_vector thread_info_to_thread_handle (struct thread_info *) override;
109 };
110
111 static char *libthread_db_search_path;
112
113 /* Set to non-zero if thread_db auto-loading is enabled
114    by the "set auto-load libthread-db" command.  */
115 static int auto_load_thread_db = 1;
116
117 /* Set to non-zero if load-time libthread_db tests have been enabled
118    by the "maintenence set check-libthread-db" command.  */
119 static int check_thread_db_on_load = 0;
120
121 /* "show" command for the auto_load_thread_db configuration variable.  */
122
123 static void
124 show_auto_load_thread_db (struct ui_file *file, int from_tty,
125                           struct cmd_list_element *c, const char *value)
126 {
127   fprintf_filtered (file, _("Auto-loading of inferior specific libthread_db "
128                             "is %s.\n"),
129                     value);
130 }
131
132 static void
133 set_libthread_db_search_path (const char *ignored, int from_tty,
134                               struct cmd_list_element *c)
135 {
136   if (*libthread_db_search_path == '\0')
137     {
138       xfree (libthread_db_search_path);
139       libthread_db_search_path = xstrdup (LIBTHREAD_DB_SEARCH_PATH);
140     }
141 }
142
143 /* If non-zero, print details of libthread_db processing.  */
144
145 static unsigned int libthread_db_debug;
146
147 static void
148 show_libthread_db_debug (struct ui_file *file, int from_tty,
149                          struct cmd_list_element *c, const char *value)
150 {
151   fprintf_filtered (file, _("libthread-db debugging is %s.\n"), value);
152 }
153
154 /* If we're running on GNU/Linux, we must explicitly attach to any new
155    threads.  */
156
157 /* This module's target vector.  */
158 static thread_db_target the_thread_db_target;
159
160 /* Non-zero if we have determined the signals used by the threads
161    library.  */
162 static int thread_signals;
163 static sigset_t thread_stop_set;
164 static sigset_t thread_print_set;
165
166 struct thread_db_info
167 {
168   struct thread_db_info *next;
169
170   /* Process id this object refers to.  */
171   int pid;
172
173   /* Handle from dlopen for libthread_db.so.  */
174   void *handle;
175
176   /* Absolute pathname from gdb_realpath to disk file used for dlopen-ing
177      HANDLE.  It may be NULL for system library.  */
178   char *filename;
179
180   /* Structure that identifies the child process for the
181      <proc_service.h> interface.  */
182   struct ps_prochandle proc_handle;
183
184   /* Connection to the libthread_db library.  */
185   td_thragent_t *thread_agent;
186
187   /* True if we need to apply the workaround for glibc/BZ5983.  When
188      we catch a PTRACE_O_TRACEFORK, and go query the child's thread
189      list, nptl_db returns the parent's threads in addition to the new
190      (single) child thread.  If this flag is set, we do extra work to
191      be able to ignore such stale entries.  */
192   int need_stale_parent_threads_check;
193
194   /* Pointers to the libthread_db functions.  */
195
196   td_init_ftype *td_init_p;
197   td_ta_new_ftype *td_ta_new_p;
198   td_ta_delete_ftype *td_ta_delete_p;
199   td_ta_map_lwp2thr_ftype *td_ta_map_lwp2thr_p;
200   td_ta_thr_iter_ftype *td_ta_thr_iter_p;
201   td_thr_get_info_ftype *td_thr_get_info_p;
202   td_thr_tls_get_addr_ftype *td_thr_tls_get_addr_p;
203   td_thr_tlsbase_ftype *td_thr_tlsbase_p;
204 };
205
206 /* List of known processes using thread_db, and the required
207    bookkeeping.  */
208 struct thread_db_info *thread_db_list;
209
210 static void thread_db_find_new_threads_1 (thread_info *stopped);
211 static void thread_db_find_new_threads_2 (thread_info *stopped,
212                                           bool until_no_new);
213
214 static void check_thread_signals (void);
215
216 static struct thread_info *record_thread
217   (struct thread_db_info *info, struct thread_info *tp,
218    ptid_t ptid, const td_thrhandle_t *th_p, const td_thrinfo_t *ti_p);
219
220 /* Add the current inferior to the list of processes using libpthread.
221    Return a pointer to the newly allocated object that was added to
222    THREAD_DB_LIST.  HANDLE is the handle returned by dlopen'ing
223    LIBTHREAD_DB_SO.  */
224
225 static struct thread_db_info *
226 add_thread_db_info (void *handle)
227 {
228   struct thread_db_info *info = XCNEW (struct thread_db_info);
229
230   info->pid = inferior_ptid.pid ();
231   info->handle = handle;
232
233   /* The workaround works by reading from /proc/pid/status, so it is
234      disabled for core files.  */
235   if (target_has_execution)
236     info->need_stale_parent_threads_check = 1;
237
238   info->next = thread_db_list;
239   thread_db_list = info;
240
241   return info;
242 }
243
244 /* Return the thread_db_info object representing the bookkeeping
245    related to process PID, if any; NULL otherwise.  */
246
247 static struct thread_db_info *
248 get_thread_db_info (int pid)
249 {
250   struct thread_db_info *info;
251
252   for (info = thread_db_list; info; info = info->next)
253     if (pid == info->pid)
254       return info;
255
256   return NULL;
257 }
258
259 static const char *thread_db_err_str (td_err_e err);
260
261 /* When PID has exited or has been detached, we no longer want to keep
262    track of it as using libpthread.  Call this function to discard
263    thread_db related info related to PID.  Note that this closes
264    LIBTHREAD_DB_SO's dlopen'ed handle.  */
265
266 static void
267 delete_thread_db_info (int pid)
268 {
269   struct thread_db_info *info, *info_prev;
270
271   info_prev = NULL;
272
273   for (info = thread_db_list; info; info_prev = info, info = info->next)
274     if (pid == info->pid)
275       break;
276
277   if (info == NULL)
278     return;
279
280   if (info->thread_agent != NULL && info->td_ta_delete_p != NULL)
281     {
282       td_err_e err = info->td_ta_delete_p (info->thread_agent);
283
284       if (err != TD_OK)
285         warning (_("Cannot deregister process %d from libthread_db: %s"),
286                  pid, thread_db_err_str (err));
287       info->thread_agent = NULL;
288     }
289
290   if (info->handle != NULL)
291     dlclose (info->handle);
292
293   xfree (info->filename);
294
295   if (info_prev)
296     info_prev->next = info->next;
297   else
298     thread_db_list = info->next;
299
300   xfree (info);
301 }
302
303 /* Use "struct private_thread_info" to cache thread state.  This is
304    a substantial optimization.  */
305
306 struct thread_db_thread_info : public private_thread_info
307 {
308   /* Flag set when we see a TD_DEATH event for this thread.  */
309   bool dying = false;
310
311   /* Cached thread state.  */
312   td_thrhandle_t th {};
313   thread_t tid {};
314 };
315
316 static thread_db_thread_info *
317 get_thread_db_thread_info (thread_info *thread)
318 {
319   return static_cast<thread_db_thread_info *> (thread->priv.get ());
320 }
321
322 static const char *
323 thread_db_err_str (td_err_e err)
324 {
325   static char buf[64];
326
327   switch (err)
328     {
329     case TD_OK:
330       return "generic 'call succeeded'";
331     case TD_ERR:
332       return "generic error";
333     case TD_NOTHR:
334       return "no thread to satisfy query";
335     case TD_NOSV:
336       return "no sync handle to satisfy query";
337     case TD_NOLWP:
338       return "no LWP to satisfy query";
339     case TD_BADPH:
340       return "invalid process handle";
341     case TD_BADTH:
342       return "invalid thread handle";
343     case TD_BADSH:
344       return "invalid synchronization handle";
345     case TD_BADTA:
346       return "invalid thread agent";
347     case TD_BADKEY:
348       return "invalid key";
349     case TD_NOMSG:
350       return "no event message for getmsg";
351     case TD_NOFPREGS:
352       return "FPU register set not available";
353     case TD_NOLIBTHREAD:
354       return "application not linked with libthread";
355     case TD_NOEVENT:
356       return "requested event is not supported";
357     case TD_NOCAPAB:
358       return "capability not available";
359     case TD_DBERR:
360       return "debugger service failed";
361     case TD_NOAPLIC:
362       return "operation not applicable to";
363     case TD_NOTSD:
364       return "no thread-specific data for this thread";
365     case TD_MALLOC:
366       return "malloc failed";
367     case TD_PARTIALREG:
368       return "only part of register set was written/read";
369     case TD_NOXREGS:
370       return "X register set not available for this thread";
371 #ifdef THREAD_DB_HAS_TD_NOTALLOC
372     case TD_NOTALLOC:
373       return "thread has not yet allocated TLS for given module";
374 #endif
375 #ifdef THREAD_DB_HAS_TD_VERSION
376     case TD_VERSION:
377       return "versions of libpthread and libthread_db do not match";
378 #endif
379 #ifdef THREAD_DB_HAS_TD_NOTLS
380     case TD_NOTLS:
381       return "there is no TLS segment in the given module";
382 #endif
383     default:
384       snprintf (buf, sizeof (buf), "unknown thread_db error '%d'", err);
385       return buf;
386     }
387 }
388
389 /* Fetch the user-level thread id of PTID.  STOPPED is a stopped
390    thread that we can use to access memory.  */
391
392 static struct thread_info *
393 thread_from_lwp (thread_info *stopped, ptid_t ptid)
394 {
395   td_thrhandle_t th;
396   td_thrinfo_t ti;
397   td_err_e err;
398   struct thread_db_info *info;
399   struct thread_info *tp;
400
401   /* Just in case td_ta_map_lwp2thr doesn't initialize it completely.  */
402   th.th_unique = 0;
403
404   /* This ptid comes from linux-nat.c, which should always fill in the
405      LWP.  */
406   gdb_assert (ptid.lwp () != 0);
407
408   info = get_thread_db_info (ptid.pid ());
409
410   /* Access an lwp we know is stopped.  */
411   info->proc_handle.thread = stopped;
412   err = info->td_ta_map_lwp2thr_p (info->thread_agent, ptid.lwp (),
413                                    &th);
414   if (err != TD_OK)
415     error (_("Cannot find user-level thread for LWP %ld: %s"),
416            ptid.lwp (), thread_db_err_str (err));
417
418   err = info->td_thr_get_info_p (&th, &ti);
419   if (err != TD_OK)
420     error (_("thread_get_info_callback: cannot get thread info: %s"),
421            thread_db_err_str (err));
422
423   /* Fill the cache.  */
424   tp = find_thread_ptid (ptid);
425   return record_thread (info, tp, ptid, &th, &ti);
426 }
427 \f
428
429 /* See linux-nat.h.  */
430
431 int
432 thread_db_notice_clone (ptid_t parent, ptid_t child)
433 {
434   struct thread_db_info *info;
435
436   info = get_thread_db_info (child.pid ());
437
438   if (info == NULL)
439     return 0;
440
441   thread_info *stopped = find_thread_ptid (parent);
442
443   thread_from_lwp (stopped, child);
444
445   /* If we do not know about the main thread's pthread info yet, this
446      would be a good time to find it.  */
447   thread_from_lwp (stopped, parent);
448   return 1;
449 }
450
451 static void *
452 verbose_dlsym (void *handle, const char *name)
453 {
454   void *sym = dlsym (handle, name);
455   if (sym == NULL)
456     warning (_("Symbol \"%s\" not found in libthread_db: %s"),
457              name, dlerror ());
458   return sym;
459 }
460
461 /* Verify inferior's '\0'-terminated symbol VER_SYMBOL starts with "%d.%d" and
462    return 1 if this version is lower (and not equal) to
463    VER_MAJOR_MIN.VER_MINOR_MIN.  Return 0 in all other cases.  */
464
465 static int
466 inferior_has_bug (const char *ver_symbol, int ver_major_min, int ver_minor_min)
467 {
468   struct bound_minimal_symbol version_msym;
469   CORE_ADDR version_addr;
470   gdb::unique_xmalloc_ptr<char> version;
471   int err, got, retval = 0;
472
473   version_msym = lookup_minimal_symbol (ver_symbol, NULL, NULL);
474   if (version_msym.minsym == NULL)
475     return 0;
476
477   version_addr = BMSYMBOL_VALUE_ADDRESS (version_msym);
478   got = target_read_string (version_addr, &version, 32, &err);
479   if (err == 0 && memchr (version.get (), 0, got) == version.get () + got - 1)
480     {
481       int major, minor;
482
483       retval = (sscanf (version.get (), "%d.%d", &major, &minor) == 2
484                 && (major < ver_major_min
485                     || (major == ver_major_min && minor < ver_minor_min)));
486     }
487
488   return retval;
489 }
490
491 /* Similar as thread_db_find_new_threads_1, but try to silently ignore errors
492    if appropriate.
493
494    Return 1 if the caller should abort libthread_db initialization.  Return 0
495    otherwise.  */
496
497 static int
498 thread_db_find_new_threads_silently (thread_info *stopped)
499 {
500
501   try
502     {
503       thread_db_find_new_threads_2 (stopped, true);
504     }
505
506   catch (const gdb_exception_error &except)
507     {
508       if (libthread_db_debug)
509         exception_fprintf (gdb_stdlog, except,
510                            "Warning: thread_db_find_new_threads_silently: ");
511
512       /* There is a bug fixed between nptl 2.6.1 and 2.7 by
513            commit 7d9d8bd18906fdd17364f372b160d7ab896ce909
514          where calls to td_thr_get_info fail with TD_ERR for statically linked
515          executables if td_thr_get_info is called before glibc has initialized
516          itself.
517          
518          If the nptl bug is NOT present in the inferior and still thread_db
519          reports an error return 1.  It means the inferior has corrupted thread
520          list and GDB should fall back only to LWPs.
521
522          If the nptl bug is present in the inferior return 0 to silently ignore
523          such errors, and let gdb enumerate threads again later.  In such case
524          GDB cannot properly display LWPs if the inferior thread list is
525          corrupted.  For core files it does not apply, no 'later enumeration'
526          is possible.  */
527
528       if (!target_has_execution || !inferior_has_bug ("nptl_version", 2, 7))
529         {
530           exception_fprintf (gdb_stderr, except,
531                              _("Warning: couldn't activate thread debugging "
532                                "using libthread_db: "));
533           return 1;
534         }
535     }
536
537   return 0;
538 }
539
540 /* Lookup a library in which given symbol resides.
541    Note: this is looking in GDB process, not in the inferior.
542    Returns library name, or NULL.  */
543
544 static const char *
545 dladdr_to_soname (const void *addr)
546 {
547   Dl_info info;
548
549   if (dladdr (addr, &info) != 0)
550     return info.dli_fname;
551   return NULL;
552 }
553
554 /* State for check_thread_db_callback.  */
555
556 struct check_thread_db_info
557 {
558   /* The libthread_db under test.  */
559   struct thread_db_info *info;
560
561   /* True if progress should be logged.  */
562   bool log_progress;
563
564   /* True if the callback was called.  */
565   bool threads_seen;
566
567   /* Name of last libthread_db function called.  */
568   const char *last_call;
569
570   /* Value returned by last libthread_db call.  */
571   td_err_e last_result;
572 };
573
574 static struct check_thread_db_info *tdb_testinfo;
575
576 /* Callback for check_thread_db.  */
577
578 static int
579 check_thread_db_callback (const td_thrhandle_t *th, void *arg)
580 {
581   gdb_assert (tdb_testinfo != NULL);
582   tdb_testinfo->threads_seen = true;
583
584 #define LOG(fmt, args...)                                               \
585   do                                                                    \
586     {                                                                   \
587       if (tdb_testinfo->log_progress)                                   \
588         {                                                               \
589           debug_printf (fmt, ## args);                                  \
590           gdb_flush (gdb_stdlog);                                       \
591         }                                                               \
592     }                                                                   \
593   while (0)
594
595 #define CHECK_1(expr, args...)                                          \
596   do                                                                    \
597     {                                                                   \
598       if (!(expr))                                                      \
599         {                                                               \
600           LOG (" ... FAIL!\n");                                         \
601           error (args);                                                 \
602         }                                                               \
603     }                                                                   \
604   while (0)
605
606 #define CHECK(expr)                                                     \
607   CHECK_1 (expr, "(%s) == false", #expr)
608
609 #define CALL_UNCHECKED(func, args...)                                   \
610   do                                                                    \
611     {                                                                   \
612       tdb_testinfo->last_call = #func;                                  \
613       tdb_testinfo->last_result                                         \
614         = tdb_testinfo->info->func ## _p (args);                        \
615     }                                                                   \
616   while (0)
617
618 #define CHECK_CALL()                                                    \
619   CHECK_1 (tdb_testinfo->last_result == TD_OK,                          \
620            _("%s failed: %s"),                                          \
621            tdb_testinfo->last_call,                                     \
622            thread_db_err_str (tdb_testinfo->last_result))               \
623
624 #define CALL(func, args...)                                             \
625   do                                                                    \
626     {                                                                   \
627       CALL_UNCHECKED (func, args);                                      \
628       CHECK_CALL ();                                                    \
629     }                                                                   \
630   while (0)
631
632   LOG ("  Got thread");
633
634   /* Check td_ta_thr_iter passed consistent arguments.  */
635   CHECK (th != NULL);
636   CHECK (arg == (void *) tdb_testinfo);
637   CHECK (th->th_ta_p == tdb_testinfo->info->thread_agent);
638
639   LOG (" %s", core_addr_to_string_nz ((CORE_ADDR) th->th_unique));
640
641   /* Check td_thr_get_info.  */
642   td_thrinfo_t ti;
643   CALL (td_thr_get_info, th, &ti);
644
645   LOG (" => %d", ti.ti_lid);
646
647   CHECK (ti.ti_ta_p == th->th_ta_p);
648   CHECK (ti.ti_tid == (thread_t) th->th_unique);
649
650   /* Check td_ta_map_lwp2thr.  */
651   td_thrhandle_t th2;
652   memset (&th2, 23, sizeof (td_thrhandle_t));
653   CALL_UNCHECKED (td_ta_map_lwp2thr, th->th_ta_p, ti.ti_lid, &th2);
654
655   if (tdb_testinfo->last_result == TD_ERR && !target_has_execution)
656     {
657       /* Some platforms require execution for td_ta_map_lwp2thr.  */
658       LOG (_("; can't map_lwp2thr"));
659     }
660   else
661     {
662       CHECK_CALL ();
663
664       LOG (" => %s", core_addr_to_string_nz ((CORE_ADDR) th2.th_unique));
665
666       CHECK (memcmp (th, &th2, sizeof (td_thrhandle_t)) == 0);
667     }
668
669   /* Attempt TLS access.  Assuming errno is TLS, this calls
670      thread_db_get_thread_local_address, which in turn calls
671      td_thr_tls_get_addr for live inferiors or td_thr_tlsbase
672      for core files.  This test is skipped if the thread has
673      not been recorded; proceeding in that case would result
674      in the test having the side-effect of noticing threads
675      which seems wrong.
676
677      Note that in glibc's libthread_db td_thr_tls_get_addr is
678      a thin wrapper around td_thr_tlsbase; this check always
679      hits the bulk of the code.
680
681      Note also that we don't actually check any libthread_db
682      calls are made, we just assume they were; future changes
683      to how GDB accesses TLS could result in this passing
684      without exercising the calls it's supposed to.  */
685   ptid_t ptid = ptid_t (tdb_testinfo->info->pid, ti.ti_lid, 0);
686   struct thread_info *thread_info = find_thread_ptid (ptid);
687   if (thread_info != NULL && thread_info->priv != NULL)
688     {
689       LOG ("; errno");
690
691       scoped_restore_current_thread restore_current_thread;
692       switch_to_thread (ptid);
693
694       expression_up expr = parse_expression ("(int) errno");
695       struct value *val = evaluate_expression (expr.get ());
696
697       if (tdb_testinfo->log_progress)
698         {
699           struct value_print_options opts;
700
701           get_user_print_options (&opts);
702           LOG (" = ");
703           value_print (val, gdb_stdlog, &opts);
704         }
705     }
706
707   LOG (" ... OK\n");
708
709 #undef LOG
710 #undef CHECK_1
711 #undef CHECK
712 #undef CALL_UNCHECKED
713 #undef CHECK_CALL
714 #undef CALL
715
716   return 0;
717 }
718
719 /* Run integrity checks on the dlopen()ed libthread_db described by
720    INFO.  Returns true on success, displays a warning and returns
721    false on failure.  Logs progress messages to gdb_stdlog during
722    the test if LOG_PROGRESS is true.  */
723
724 static bool
725 check_thread_db (struct thread_db_info *info, bool log_progress)
726 {
727   bool test_passed = true;
728
729   if (log_progress)
730     debug_printf (_("Running libthread_db integrity checks:\n"));
731
732   /* GDB avoids using td_ta_thr_iter wherever possible (see comment
733      in try_thread_db_load_1 below) so in order to test it we may
734      have to locate it ourselves.  */
735   td_ta_thr_iter_ftype *td_ta_thr_iter_p = info->td_ta_thr_iter_p;
736   if (td_ta_thr_iter_p == NULL)
737     {
738       void *thr_iter = verbose_dlsym (info->handle, "td_ta_thr_iter");
739       if (thr_iter == NULL)
740         return 0;
741
742       td_ta_thr_iter_p = (td_ta_thr_iter_ftype *) thr_iter;
743     }
744
745   /* Set up the test state we share with the callback.  */
746   gdb_assert (tdb_testinfo == NULL);
747   struct check_thread_db_info tdb_testinfo_buf;
748   tdb_testinfo = &tdb_testinfo_buf;
749
750   memset (tdb_testinfo, 0, sizeof (struct check_thread_db_info));
751   tdb_testinfo->info = info;
752   tdb_testinfo->log_progress = log_progress;
753
754   /* td_ta_thr_iter shouldn't be used on running processes.  Note that
755      it's possible the inferior will stop midway through modifying one
756      of its thread lists, in which case the check will spuriously
757      fail.  */
758   linux_stop_and_wait_all_lwps ();
759
760   try
761     {
762       td_err_e err = td_ta_thr_iter_p (info->thread_agent,
763                                        check_thread_db_callback,
764                                        tdb_testinfo,
765                                        TD_THR_ANY_STATE,
766                                        TD_THR_LOWEST_PRIORITY,
767                                        TD_SIGNO_MASK,
768                                        TD_THR_ANY_USER_FLAGS);
769
770       if (err != TD_OK)
771         error (_("td_ta_thr_iter failed: %s"), thread_db_err_str (err));
772
773       if (!tdb_testinfo->threads_seen)
774         error (_("no threads seen"));
775     }
776   catch (const gdb_exception_error &except)
777     {
778       if (warning_pre_print)
779         fputs_unfiltered (warning_pre_print, gdb_stderr);
780
781       exception_fprintf (gdb_stderr, except,
782                          _("libthread_db integrity checks failed: "));
783
784       test_passed = false;
785     }
786
787   if (test_passed && log_progress)
788     debug_printf (_("libthread_db integrity checks passed.\n"));
789
790   tdb_testinfo = NULL;
791
792   linux_unstop_all_lwps ();
793
794   return test_passed;
795 }
796
797 /* Attempt to initialize dlopen()ed libthread_db, described by INFO.
798    Return true on success.
799    Failure could happen if libthread_db does not have symbols we expect,
800    or when it refuses to work with the current inferior (e.g. due to
801    version mismatch between libthread_db and libpthread).  */
802
803 static bool
804 try_thread_db_load_1 (struct thread_db_info *info)
805 {
806   td_err_e err;
807
808   /* Initialize pointers to the dynamic library functions we will use.
809      Essential functions first.  */
810
811 #define TDB_VERBOSE_DLSYM(info, func)                   \
812   info->func ## _p = (func ## _ftype *) verbose_dlsym (info->handle, #func)
813
814 #define TDB_DLSYM(info, func)                   \
815   info->func ## _p = (func ## _ftype *) dlsym (info->handle, #func)
816
817 #define CHK(a)                                                          \
818   do                                                                    \
819     {                                                                   \
820       if ((a) == NULL)                                                  \
821         return false;                                                   \
822   } while (0)
823
824   CHK (TDB_VERBOSE_DLSYM (info, td_init));
825
826   err = info->td_init_p ();
827   if (err != TD_OK)
828     {
829       warning (_("Cannot initialize libthread_db: %s"),
830                thread_db_err_str (err));
831       return false;
832     }
833
834   CHK (TDB_VERBOSE_DLSYM (info, td_ta_new));
835
836   /* Initialize the structure that identifies the child process.  */
837   info->proc_handle.thread = inferior_thread ();
838
839   /* Now attempt to open a connection to the thread library.  */
840   err = info->td_ta_new_p (&info->proc_handle, &info->thread_agent);
841   if (err != TD_OK)
842     {
843       if (libthread_db_debug)
844         fprintf_unfiltered (gdb_stdlog, _("td_ta_new failed: %s\n"),
845                             thread_db_err_str (err));
846       else
847         switch (err)
848           {
849             case TD_NOLIBTHREAD:
850 #ifdef THREAD_DB_HAS_TD_VERSION
851             case TD_VERSION:
852 #endif
853               /* The errors above are not unexpected and silently ignored:
854                  they just mean we haven't found correct version of
855                  libthread_db yet.  */
856               break;
857             default:
858               warning (_("td_ta_new failed: %s"), thread_db_err_str (err));
859           }
860       return false;
861     }
862
863   /* These are essential.  */
864   CHK (TDB_VERBOSE_DLSYM (info, td_ta_map_lwp2thr));
865   CHK (TDB_VERBOSE_DLSYM (info, td_thr_get_info));
866
867   /* These are not essential.  */
868   TDB_DLSYM (info, td_thr_tls_get_addr);
869   TDB_DLSYM (info, td_thr_tlsbase);
870   TDB_DLSYM (info, td_ta_delete);
871
872   /* It's best to avoid td_ta_thr_iter if possible.  That walks data
873      structures in the inferior's address space that may be corrupted,
874      or, if the target is running, may change while we walk them.  If
875      there's execution (and /proc is mounted), then we're already
876      attached to all LWPs.  Use thread_from_lwp, which uses
877      td_ta_map_lwp2thr instead, which does not walk the thread list.
878
879      td_ta_map_lwp2thr uses ps_get_thread_area, but we can't use that
880      currently on core targets, as it uses ptrace directly.  */
881   if (target_has_execution
882       && linux_proc_task_list_dir_exists (inferior_ptid.pid ()))
883     info->td_ta_thr_iter_p = NULL;
884   else
885     CHK (TDB_VERBOSE_DLSYM (info, td_ta_thr_iter));
886
887 #undef TDB_VERBOSE_DLSYM
888 #undef TDB_DLSYM
889 #undef CHK
890
891   /* Run integrity checks if requested.  */
892   if (check_thread_db_on_load)
893     {
894       if (!check_thread_db (info, libthread_db_debug))
895         return false;
896     }
897
898   if (info->td_ta_thr_iter_p == NULL)
899     {
900       struct lwp_info *lp;
901       int pid = inferior_ptid.pid ();
902       thread_info *curr_thread = inferior_thread ();
903
904       linux_stop_and_wait_all_lwps ();
905
906       ALL_LWPS (lp)
907         if (lp->ptid.pid () == pid)
908           thread_from_lwp (curr_thread, lp->ptid);
909
910       linux_unstop_all_lwps ();
911     }
912   else if (thread_db_find_new_threads_silently (inferior_thread ()) != 0)
913     {
914       /* Even if libthread_db initializes, if the thread list is
915          corrupted, we'd not manage to list any threads.  Better reject this
916          thread_db, and fall back to at least listing LWPs.  */
917       return false;
918     }
919
920   printf_unfiltered (_("[Thread debugging using libthread_db enabled]\n"));
921
922   if (*libthread_db_search_path || libthread_db_debug)
923     {
924       struct ui_file *file;
925       const char *library;
926
927       library = dladdr_to_soname ((const void *) *info->td_ta_new_p);
928       if (library == NULL)
929         library = LIBTHREAD_DB_SO;
930
931       /* If we'd print this to gdb_stdout when debug output is
932          disabled, still print it to gdb_stdout if debug output is
933          enabled.  User visible output should not depend on debug
934          settings.  */
935       file = *libthread_db_search_path != '\0' ? gdb_stdout : gdb_stdlog;
936       fprintf_unfiltered (file, _("Using host libthread_db library \"%s\".\n"),
937                           library);
938     }
939
940   /* The thread library was detected.  Activate the thread_db target
941      if this is the first process using it.  */
942   if (thread_db_list->next == NULL)
943     push_target (&the_thread_db_target);
944
945   return true;
946 }
947
948 /* Attempt to use LIBRARY as libthread_db.  LIBRARY could be absolute,
949    relative, or just LIBTHREAD_DB.  */
950
951 static bool
952 try_thread_db_load (const char *library, bool check_auto_load_safe)
953 {
954   void *handle;
955   struct thread_db_info *info;
956
957   if (libthread_db_debug)
958     fprintf_unfiltered (gdb_stdlog,
959                         _("Trying host libthread_db library: %s.\n"),
960                         library);
961
962   if (check_auto_load_safe)
963     {
964       if (access (library, R_OK) != 0)
965         {
966           /* Do not print warnings by file_is_auto_load_safe if the library does
967              not exist at this place.  */
968           if (libthread_db_debug)
969             fprintf_unfiltered (gdb_stdlog, _("open failed: %s.\n"),
970                                 safe_strerror (errno));
971           return false;
972         }
973
974       if (!file_is_auto_load_safe (library, _("auto-load: Loading libthread-db "
975                                               "library \"%s\" from explicit "
976                                               "directory.\n"),
977                                    library))
978         return false;
979     }
980
981   handle = dlopen (library, RTLD_NOW);
982   if (handle == NULL)
983     {
984       if (libthread_db_debug)
985         fprintf_unfiltered (gdb_stdlog, _("dlopen failed: %s.\n"), dlerror ());
986       return false;
987     }
988
989   if (libthread_db_debug && strchr (library, '/') == NULL)
990     {
991       void *td_init;
992
993       td_init = dlsym (handle, "td_init");
994       if (td_init != NULL)
995         {
996           const char *const libpath = dladdr_to_soname (td_init);
997
998           if (libpath != NULL)
999             fprintf_unfiltered (gdb_stdlog, _("Host %s resolved to: %s.\n"),
1000                                library, libpath);
1001         }
1002     }
1003
1004   info = add_thread_db_info (handle);
1005
1006   /* Do not save system library name, that one is always trusted.  */
1007   if (strchr (library, '/') != NULL)
1008     info->filename = gdb_realpath (library).release ();
1009
1010   if (try_thread_db_load_1 (info))
1011     return true;
1012
1013   /* This library "refused" to work on current inferior.  */
1014   delete_thread_db_info (inferior_ptid.pid ());
1015   return false;
1016 }
1017
1018 /* Subroutine of try_thread_db_load_from_pdir to simplify it.
1019    Try loading libthread_db in directory(OBJ)/SUBDIR.
1020    SUBDIR may be NULL.  It may also be something like "../lib64".
1021    The result is true for success.  */
1022
1023 static bool
1024 try_thread_db_load_from_pdir_1 (struct objfile *obj, const char *subdir)
1025 {
1026   const char *obj_name = objfile_name (obj);
1027
1028   if (obj_name[0] != '/')
1029     {
1030       warning (_("Expected absolute pathname for libpthread in the"
1031                  " inferior, but got %s."), obj_name);
1032       return false;
1033     }
1034
1035   std::string path = obj_name;
1036   size_t cp = path.rfind ('/');
1037   /* This should at minimum hit the first character.  */
1038   gdb_assert (cp != std::string::npos);
1039   path.resize (cp + 1);
1040   if (subdir != NULL)
1041     path = path + subdir + "/";
1042   path += LIBTHREAD_DB_SO;
1043
1044   return try_thread_db_load (path.c_str (), true);
1045 }
1046
1047 /* Handle $pdir in libthread-db-search-path.
1048    Look for libthread_db in directory(libpthread)/SUBDIR.
1049    SUBDIR may be NULL.  It may also be something like "../lib64".
1050    The result is true for success.  */
1051
1052 static bool
1053 try_thread_db_load_from_pdir (const char *subdir)
1054 {
1055   if (!auto_load_thread_db)
1056     return false;
1057
1058   for (objfile *obj : current_program_space->objfiles ())
1059     if (libpthread_name_p (objfile_name (obj)))
1060       {
1061         if (try_thread_db_load_from_pdir_1 (obj, subdir))
1062           return true;
1063
1064         /* We may have found the separate-debug-info version of
1065            libpthread, and it may live in a directory without a matching
1066            libthread_db.  */
1067         if (obj->separate_debug_objfile_backlink != NULL)
1068           return try_thread_db_load_from_pdir_1 (obj->separate_debug_objfile_backlink,
1069                                                  subdir);
1070
1071         return false;
1072       }
1073
1074   return false;
1075 }
1076
1077 /* Handle $sdir in libthread-db-search-path.
1078    Look for libthread_db in the system dirs, or wherever a plain
1079    dlopen(file_without_path) will look.
1080    The result is true for success.  */
1081
1082 static bool
1083 try_thread_db_load_from_sdir (void)
1084 {
1085   return try_thread_db_load (LIBTHREAD_DB_SO, false);
1086 }
1087
1088 /* Try to load libthread_db from directory DIR of length DIR_LEN.
1089    The result is true for success.  */
1090
1091 static bool
1092 try_thread_db_load_from_dir (const char *dir, size_t dir_len)
1093 {
1094   if (!auto_load_thread_db)
1095     return false;
1096
1097   std::string path = std::string (dir, dir_len) + "/" + LIBTHREAD_DB_SO;
1098
1099   return try_thread_db_load (path.c_str (), true);
1100 }
1101
1102 /* Search libthread_db_search_path for libthread_db which "agrees"
1103    to work on current inferior.
1104    The result is true for success.  */
1105
1106 static bool
1107 thread_db_load_search (void)
1108 {
1109   bool rc = false;
1110
1111   std::vector<gdb::unique_xmalloc_ptr<char>> dir_vec
1112     = dirnames_to_char_ptr_vec (libthread_db_search_path);
1113
1114   for (const gdb::unique_xmalloc_ptr<char> &this_dir_up : dir_vec)
1115     {
1116       const char *this_dir = this_dir_up.get ();
1117       const int pdir_len = sizeof ("$pdir") - 1;
1118       size_t this_dir_len;
1119
1120       this_dir_len = strlen (this_dir);
1121
1122       if (strncmp (this_dir, "$pdir", pdir_len) == 0
1123           && (this_dir[pdir_len] == '\0'
1124               || this_dir[pdir_len] == '/'))
1125         {
1126           const char *subdir = NULL;
1127
1128           std::string subdir_holder;
1129           if (this_dir[pdir_len] == '/')
1130             {
1131               subdir_holder = std::string (this_dir + pdir_len + 1);
1132               subdir = subdir_holder.c_str ();
1133             }
1134           rc = try_thread_db_load_from_pdir (subdir);
1135           if (rc)
1136             break;
1137         }
1138       else if (strcmp (this_dir, "$sdir") == 0)
1139         {
1140           if (try_thread_db_load_from_sdir ())
1141             {
1142               rc = 1;
1143               break;
1144             }
1145         }
1146       else
1147         {
1148           if (try_thread_db_load_from_dir (this_dir, this_dir_len))
1149             {
1150               rc = 1;
1151               break;
1152             }
1153         }
1154     }
1155
1156   if (libthread_db_debug)
1157     fprintf_unfiltered (gdb_stdlog,
1158                         _("thread_db_load_search returning %d\n"), rc);
1159   return rc;
1160 }
1161
1162 /* Return true if the inferior has a libpthread.  */
1163
1164 static bool
1165 has_libpthread (void)
1166 {
1167   for (objfile *obj : current_program_space->objfiles ())
1168     if (libpthread_name_p (objfile_name (obj)))
1169       return true;
1170
1171   return false;
1172 }
1173
1174 /* Attempt to load and initialize libthread_db.
1175    Return 1 on success.  */
1176
1177 static bool
1178 thread_db_load (void)
1179 {
1180   struct thread_db_info *info;
1181
1182   info = get_thread_db_info (inferior_ptid.pid ());
1183
1184   if (info != NULL)
1185     return true;
1186
1187   /* Don't attempt to use thread_db on executables not running
1188      yet.  */
1189   if (!target_has_registers)
1190     return false;
1191
1192   /* Don't attempt to use thread_db for remote targets.  */
1193   if (!(target_can_run () || core_bfd))
1194     return false;
1195
1196   if (thread_db_load_search ())
1197     return true;
1198
1199   /* We couldn't find a libthread_db.
1200      If the inferior has a libpthread warn the user.  */
1201   if (has_libpthread ())
1202     {
1203       warning (_("Unable to find libthread_db matching inferior's thread"
1204                  " library, thread debugging will not be available."));
1205       return false;
1206     }
1207
1208   /* Either this executable isn't using libpthread at all, or it is
1209      statically linked.  Since we can't easily distinguish these two cases,
1210      no warning is issued.  */
1211   return false;
1212 }
1213
1214 static void
1215 check_thread_signals (void)
1216 {
1217   if (!thread_signals)
1218     {
1219       sigset_t mask;
1220       int i;
1221
1222       lin_thread_get_thread_signals (&mask);
1223       sigemptyset (&thread_stop_set);
1224       sigemptyset (&thread_print_set);
1225
1226       for (i = 1; i < NSIG; i++)
1227         {
1228           if (sigismember (&mask, i))
1229             {
1230               if (signal_stop_update (gdb_signal_from_host (i), 0))
1231                 sigaddset (&thread_stop_set, i);
1232               if (signal_print_update (gdb_signal_from_host (i), 0))
1233                 sigaddset (&thread_print_set, i);
1234               thread_signals = 1;
1235             }
1236         }
1237     }
1238 }
1239
1240 /* Check whether thread_db is usable.  This function is called when
1241    an inferior is created (or otherwise acquired, e.g. attached to)
1242    and when new shared libraries are loaded into a running process.  */
1243
1244 void
1245 check_for_thread_db (void)
1246 {
1247   /* Do nothing if we couldn't load libthread_db.so.1.  */
1248   if (!thread_db_load ())
1249     return;
1250 }
1251
1252 /* This function is called via the new_objfile observer.  */
1253
1254 static void
1255 thread_db_new_objfile (struct objfile *objfile)
1256 {
1257   /* This observer must always be called with inferior_ptid set
1258      correctly.  */
1259
1260   if (objfile != NULL
1261       /* libpthread with separate debug info has its debug info file already
1262          loaded (and notified without successful thread_db initialization)
1263          the time gdb::observers::new_objfile.notify is called for the library itself.
1264          Static executables have their separate debug info loaded already
1265          before the inferior has started.  */
1266       && objfile->separate_debug_objfile_backlink == NULL
1267       /* Only check for thread_db if we loaded libpthread,
1268          or if this is the main symbol file.
1269          We need to check OBJF_MAINLINE to handle the case of debugging
1270          a statically linked executable AND the symbol file is specified AFTER
1271          the exec file is loaded (e.g., gdb -c core ; file foo).
1272          For dynamically linked executables, libpthread can be near the end
1273          of the list of shared libraries to load, and in an app of several
1274          thousand shared libraries, this can otherwise be painful.  */
1275       && ((objfile->flags & OBJF_MAINLINE) != 0
1276           || libpthread_name_p (objfile_name (objfile))))
1277     check_for_thread_db ();
1278 }
1279
1280 static void
1281 check_pid_namespace_match (void)
1282 {
1283   /* Check is only relevant for local targets targets.  */
1284   if (target_can_run ())
1285     {
1286       /* If the child is in a different PID namespace, its idea of its
1287          PID will differ from our idea of its PID.  When we scan the
1288          child's thread list, we'll mistakenly think it has no threads
1289          since the thread PID fields won't match the PID we give to
1290          libthread_db.  */
1291       if (!linux_ns_same (inferior_ptid.pid (), LINUX_NS_PID))
1292         {
1293           warning (_ ("Target and debugger are in different PID "
1294                       "namespaces; thread lists and other data are "
1295                       "likely unreliable.  "
1296                       "Connect to gdbserver inside the container."));
1297         }
1298     }
1299 }
1300
1301 /* This function is called via the inferior_created observer.
1302    This handles the case of debugging statically linked executables.  */
1303
1304 static void
1305 thread_db_inferior_created (struct target_ops *target, int from_tty)
1306 {
1307   check_pid_namespace_match ();
1308   check_for_thread_db ();
1309 }
1310
1311 /* Update the thread's state (what's displayed in "info threads"),
1312    from libthread_db thread state information.  */
1313
1314 static void
1315 update_thread_state (thread_db_thread_info *priv,
1316                      const td_thrinfo_t *ti_p)
1317 {
1318   priv->dying = (ti_p->ti_state == TD_THR_UNKNOWN
1319                  || ti_p->ti_state == TD_THR_ZOMBIE);
1320 }
1321
1322 /* Record a new thread in GDB's thread list.  Creates the thread's
1323    private info.  If TP is NULL or TP is marked as having exited,
1324    creates a new thread.  Otherwise, uses TP.  */
1325
1326 static struct thread_info *
1327 record_thread (struct thread_db_info *info,
1328                struct thread_info *tp,
1329                ptid_t ptid, const td_thrhandle_t *th_p,
1330                const td_thrinfo_t *ti_p)
1331 {
1332   /* A thread ID of zero may mean the thread library has not
1333      initialized yet.  Leave private == NULL until the thread library
1334      has initialized.  */
1335   if (ti_p->ti_tid == 0)
1336     return tp;
1337
1338   /* Construct the thread's private data.  */
1339   thread_db_thread_info *priv = new thread_db_thread_info;
1340
1341   priv->th = *th_p;
1342   priv->tid = ti_p->ti_tid;
1343   update_thread_state (priv, ti_p);
1344
1345   /* Add the thread to GDB's thread list.  If we already know about a
1346      thread with this PTID, but it's marked exited, then the kernel
1347      reused the tid of an old thread.  */
1348   if (tp == NULL || tp->state == THREAD_EXITED)
1349     tp = add_thread_with_info (ptid, priv);
1350   else
1351     tp->priv.reset (priv);
1352
1353   if (target_has_execution)
1354     check_thread_signals ();
1355
1356   return tp;
1357 }
1358
1359 void
1360 thread_db_target::detach (inferior *inf, int from_tty)
1361 {
1362   delete_thread_db_info (inf->pid);
1363
1364   beneath ()->detach (inf, from_tty);
1365
1366   /* NOTE: From this point on, inferior_ptid is null_ptid.  */
1367
1368   /* If there are no more processes using libpthread, detach the
1369      thread_db target ops.  */
1370   if (!thread_db_list)
1371     unpush_target (this);
1372 }
1373
1374 ptid_t
1375 thread_db_target::wait (ptid_t ptid, struct target_waitstatus *ourstatus,
1376                         int options)
1377 {
1378   struct thread_db_info *info;
1379
1380   ptid = beneath ()->wait (ptid, ourstatus, options);
1381
1382   switch (ourstatus->kind)
1383     {
1384     case TARGET_WAITKIND_IGNORE:
1385     case TARGET_WAITKIND_EXITED:
1386     case TARGET_WAITKIND_THREAD_EXITED:
1387     case TARGET_WAITKIND_SIGNALLED:
1388       return ptid;
1389     }
1390
1391   info = get_thread_db_info (ptid.pid ());
1392
1393   /* If this process isn't using thread_db, we're done.  */
1394   if (info == NULL)
1395     return ptid;
1396
1397   if (ourstatus->kind == TARGET_WAITKIND_EXECD)
1398     {
1399       /* New image, it may or may not end up using thread_db.  Assume
1400          not unless we find otherwise.  */
1401       delete_thread_db_info (ptid.pid ());
1402       if (!thread_db_list)
1403         unpush_target (&the_thread_db_target);
1404
1405       return ptid;
1406     }
1407
1408   /* Fill in the thread's user-level thread id and status.  */
1409   thread_from_lwp (find_thread_ptid (ptid), ptid);
1410
1411   return ptid;
1412 }
1413
1414 void
1415 thread_db_target::mourn_inferior ()
1416 {
1417   delete_thread_db_info (inferior_ptid.pid ());
1418
1419   beneath ()->mourn_inferior ();
1420
1421   /* Detach thread_db target ops.  */
1422   if (!thread_db_list)
1423     unpush_target (&the_thread_db_target);
1424 }
1425
1426 struct callback_data
1427 {
1428   struct thread_db_info *info;
1429   int new_threads;
1430 };
1431
1432 static int
1433 find_new_threads_callback (const td_thrhandle_t *th_p, void *data)
1434 {
1435   td_thrinfo_t ti;
1436   td_err_e err;
1437   struct thread_info *tp;
1438   struct callback_data *cb_data = (struct callback_data *) data;
1439   struct thread_db_info *info = cb_data->info;
1440
1441   err = info->td_thr_get_info_p (th_p, &ti);
1442   if (err != TD_OK)
1443     error (_("find_new_threads_callback: cannot get thread info: %s"),
1444            thread_db_err_str (err));
1445
1446   if (ti.ti_lid == -1)
1447     {
1448       /* A thread with kernel thread ID -1 is either a thread that
1449          exited and was joined, or a thread that is being created but
1450          hasn't started yet, and that is reusing the tcb/stack of a
1451          thread that previously exited and was joined.  (glibc marks
1452          terminated and joined threads with kernel thread ID -1.  See
1453          glibc PR17707.  */
1454       if (libthread_db_debug)
1455         fprintf_unfiltered (gdb_stdlog,
1456                             "thread_db: skipping exited and "
1457                             "joined thread (0x%lx)\n",
1458                             (unsigned long) ti.ti_tid);
1459       return 0;
1460     }
1461
1462   if (ti.ti_tid == 0)
1463     {
1464       /* A thread ID of zero means that this is the main thread, but
1465          glibc has not yet initialized thread-local storage and the
1466          pthread library.  We do not know what the thread's TID will
1467          be yet.  */
1468
1469       /* In that case, we're not stopped in a fork syscall and don't
1470          need this glibc bug workaround.  */
1471       info->need_stale_parent_threads_check = 0;
1472
1473       return 0;
1474     }
1475
1476   /* Ignore stale parent threads, caused by glibc/BZ5983.  This is a
1477      bit expensive, as it needs to open /proc/pid/status, so try to
1478      avoid doing the work if we know we don't have to.  */
1479   if (info->need_stale_parent_threads_check)
1480     {
1481       int tgid = linux_proc_get_tgid (ti.ti_lid);
1482
1483       if (tgid != -1 && tgid != info->pid)
1484         return 0;
1485     }
1486
1487   ptid_t ptid (info->pid, ti.ti_lid);
1488   tp = find_thread_ptid (ptid);
1489   if (tp == NULL || tp->priv == NULL)
1490     record_thread (info, tp, ptid, th_p, &ti);
1491
1492   return 0;
1493 }
1494
1495 /* Helper for thread_db_find_new_threads_2.
1496    Returns number of new threads found.  */
1497
1498 static int
1499 find_new_threads_once (struct thread_db_info *info, int iteration,
1500                        td_err_e *errp)
1501 {
1502   struct callback_data data;
1503   td_err_e err = TD_ERR;
1504
1505   data.info = info;
1506   data.new_threads = 0;
1507
1508   /* See comment in thread_db_update_thread_list.  */
1509   gdb_assert (info->td_ta_thr_iter_p != NULL);
1510
1511   try
1512     {
1513       /* Iterate over all user-space threads to discover new threads.  */
1514       err = info->td_ta_thr_iter_p (info->thread_agent,
1515                                     find_new_threads_callback,
1516                                     &data,
1517                                     TD_THR_ANY_STATE,
1518                                     TD_THR_LOWEST_PRIORITY,
1519                                     TD_SIGNO_MASK,
1520                                     TD_THR_ANY_USER_FLAGS);
1521     }
1522   catch (const gdb_exception_error &except)
1523     {
1524       if (libthread_db_debug)
1525         {
1526           exception_fprintf (gdb_stdlog, except,
1527                              "Warning: find_new_threads_once: ");
1528         }
1529     }
1530
1531   if (libthread_db_debug)
1532     {
1533       fprintf_unfiltered (gdb_stdlog,
1534                           _("Found %d new threads in iteration %d.\n"),
1535                           data.new_threads, iteration);
1536     }
1537
1538   if (errp != NULL)
1539     *errp = err;
1540
1541   return data.new_threads;
1542 }
1543
1544 /* Search for new threads, accessing memory through stopped thread
1545    PTID.  If UNTIL_NO_NEW is true, repeat searching until several
1546    searches in a row do not discover any new threads.  */
1547
1548 static void
1549 thread_db_find_new_threads_2 (thread_info *stopped, bool until_no_new)
1550 {
1551   td_err_e err = TD_OK;
1552   struct thread_db_info *info;
1553   int i, loop;
1554
1555   info = get_thread_db_info (stopped->ptid.pid ());
1556
1557   /* Access an lwp we know is stopped.  */
1558   info->proc_handle.thread = stopped;
1559
1560   if (until_no_new)
1561     {
1562       /* Require 4 successive iterations which do not find any new threads.
1563          The 4 is a heuristic: there is an inherent race here, and I have
1564          seen that 2 iterations in a row are not always sufficient to
1565          "capture" all threads.  */
1566       for (i = 0, loop = 0; loop < 4 && err == TD_OK; ++i, ++loop)
1567         if (find_new_threads_once (info, i, &err) != 0)
1568           {
1569             /* Found some new threads.  Restart the loop from beginning.  */
1570             loop = -1;
1571           }
1572     }
1573   else
1574     find_new_threads_once (info, 0, &err);
1575
1576   if (err != TD_OK)
1577     error (_("Cannot find new threads: %s"), thread_db_err_str (err));
1578 }
1579
1580 static void
1581 thread_db_find_new_threads_1 (thread_info *stopped)
1582 {
1583   thread_db_find_new_threads_2 (stopped, 0);
1584 }
1585
1586 /* Implement the to_update_thread_list target method for this
1587    target.  */
1588
1589 void
1590 thread_db_target::update_thread_list ()
1591 {
1592   struct thread_db_info *info;
1593
1594   prune_threads ();
1595
1596   for (inferior *inf : all_inferiors ())
1597     {
1598       struct thread_info *thread;
1599
1600       if (inf->pid == 0)
1601         continue;
1602
1603       info = get_thread_db_info (inf->pid);
1604       if (info == NULL)
1605         continue;
1606
1607       thread = any_live_thread_of_inferior (inf);
1608       if (thread == NULL || thread->executing)
1609         continue;
1610
1611       /* It's best to avoid td_ta_thr_iter if possible.  That walks
1612          data structures in the inferior's address space that may be
1613          corrupted, or, if the target is running, the list may change
1614          while we walk it.  In the latter case, it's possible that a
1615          thread exits just at the exact time that causes GDB to get
1616          stuck in an infinite loop.  To avoid pausing all threads
1617          whenever the core wants to refresh the thread list, we
1618          instead use thread_from_lwp immediately when we see an LWP
1619          stop.  That uses thread_db entry points that do not walk
1620          libpthread's thread list, so should be safe, as well as more
1621          efficient.  */
1622       if (target_has_execution_1 (thread->ptid))
1623         continue;
1624
1625       thread_db_find_new_threads_1 (thread);
1626     }
1627
1628   /* Give the beneath target a chance to do extra processing.  */
1629   this->beneath ()->update_thread_list ();
1630 }
1631
1632 std::string
1633 thread_db_target::pid_to_str (ptid_t ptid)
1634 {
1635   struct thread_info *thread_info = find_thread_ptid (ptid);
1636
1637   if (thread_info != NULL && thread_info->priv != NULL)
1638     {
1639       thread_db_thread_info *priv = get_thread_db_thread_info (thread_info);
1640
1641       return string_printf ("Thread 0x%lx (LWP %ld)",
1642                             (unsigned long) priv->tid, ptid.lwp ());
1643     }
1644
1645   return beneath ()->pid_to_str (ptid);
1646 }
1647
1648 /* Return a string describing the state of the thread specified by
1649    INFO.  */
1650
1651 const char *
1652 thread_db_target::extra_thread_info (thread_info *info)
1653 {
1654   if (info->priv == NULL)
1655     return NULL;
1656
1657   thread_db_thread_info *priv = get_thread_db_thread_info (info);
1658
1659   if (priv->dying)
1660     return "Exiting";
1661
1662   return NULL;
1663 }
1664
1665 /* Return pointer to the thread_info struct which corresponds to
1666    THREAD_HANDLE (having length HANDLE_LEN).  */
1667
1668 thread_info *
1669 thread_db_target::thread_handle_to_thread_info (const gdb_byte *thread_handle,
1670                                                 int handle_len,
1671                                                 inferior *inf)
1672 {
1673   thread_t handle_tid;
1674
1675   /* When debugging a 32-bit target from a 64-bit host, handle_len
1676      will be 4 and sizeof (handle_tid) will be 8.  This requires
1677      a different cast than the more straightforward case where
1678      the sizes are the same.
1679
1680      Use "--target_board unix/-m32" from a native x86_64 linux build
1681      to test the 32/64-bit case.  */
1682   if (handle_len == 4 && sizeof (handle_tid) == 8)
1683     handle_tid = (thread_t) * (const uint32_t *) thread_handle;
1684   else if (handle_len == sizeof (handle_tid))
1685     handle_tid = * (const thread_t *) thread_handle;
1686   else
1687     error (_("Thread handle size mismatch: %d vs %zu (from libthread_db)"),
1688            handle_len, sizeof (handle_tid));
1689
1690   for (thread_info *tp : inf->non_exited_threads ())
1691     {
1692       thread_db_thread_info *priv = get_thread_db_thread_info (tp);
1693
1694       if (priv != NULL && handle_tid == priv->tid)
1695         return tp;
1696     }
1697
1698   return NULL;
1699 }
1700
1701 /* Return the thread handle associated the thread_info pointer TP.  */
1702
1703 gdb::byte_vector
1704 thread_db_target::thread_info_to_thread_handle (struct thread_info *tp)
1705 {
1706   thread_db_thread_info *priv = get_thread_db_thread_info (tp);
1707
1708   if (priv == NULL)
1709     return gdb::byte_vector ();
1710
1711   int handle_size = sizeof (priv->tid);
1712   gdb::byte_vector rv (handle_size);
1713
1714   memcpy (rv.data (), &priv->tid, handle_size);
1715
1716   return rv;
1717 }
1718
1719 /* Get the address of the thread local variable in load module LM which
1720    is stored at OFFSET within the thread local storage for thread PTID.  */
1721
1722 CORE_ADDR
1723 thread_db_target::get_thread_local_address (ptid_t ptid,
1724                                             CORE_ADDR lm,
1725                                             CORE_ADDR offset)
1726 {
1727   struct thread_info *thread_info;
1728
1729   /* Find the matching thread.  */
1730   thread_info = find_thread_ptid (ptid);
1731
1732   /* We may not have discovered the thread yet.  */
1733   if (thread_info != NULL && thread_info->priv == NULL)
1734     thread_info = thread_from_lwp (thread_info, ptid);
1735
1736   if (thread_info != NULL && thread_info->priv != NULL)
1737     {
1738       td_err_e err;
1739       psaddr_t address;
1740       thread_db_info *info = get_thread_db_info (ptid.pid ());
1741       thread_db_thread_info *priv = get_thread_db_thread_info (thread_info);
1742
1743       /* Finally, get the address of the variable.  */
1744       if (lm != 0)
1745         {
1746           /* glibc doesn't provide the needed interface.  */
1747           if (!info->td_thr_tls_get_addr_p)
1748             throw_error (TLS_NO_LIBRARY_SUPPORT_ERROR,
1749                          _("No TLS library support"));
1750
1751           /* Note the cast through uintptr_t: this interface only works if
1752              a target address fits in a psaddr_t, which is a host pointer.
1753              So a 32-bit debugger can not access 64-bit TLS through this.  */
1754           err = info->td_thr_tls_get_addr_p (&priv->th,
1755                                              (psaddr_t)(uintptr_t) lm,
1756                                              offset, &address);
1757         }
1758       else
1759         {
1760           /* If glibc doesn't provide the needed interface throw an error
1761              that LM is zero - normally cases it should not be.  */
1762           if (!info->td_thr_tlsbase_p)
1763             throw_error (TLS_LOAD_MODULE_NOT_FOUND_ERROR,
1764                          _("TLS load module not found"));
1765
1766           /* This code path handles the case of -static -pthread executables:
1767              https://sourceware.org/ml/libc-help/2014-03/msg00024.html
1768              For older GNU libc r_debug.r_map is NULL.  For GNU libc after
1769              PR libc/16831 due to GDB PR threads/16954 LOAD_MODULE is also NULL.
1770              The constant number 1 depends on GNU __libc_setup_tls
1771              initialization of l_tls_modid to 1.  */
1772           err = info->td_thr_tlsbase_p (&priv->th, 1, &address);
1773           address = (char *) address + offset;
1774         }
1775
1776 #ifdef THREAD_DB_HAS_TD_NOTALLOC
1777       /* The memory hasn't been allocated, yet.  */
1778       if (err == TD_NOTALLOC)
1779           /* Now, if libthread_db provided the initialization image's
1780              address, we *could* try to build a non-lvalue value from
1781              the initialization image.  */
1782         throw_error (TLS_NOT_ALLOCATED_YET_ERROR,
1783                      _("TLS not allocated yet"));
1784 #endif
1785
1786       /* Something else went wrong.  */
1787       if (err != TD_OK)
1788         throw_error (TLS_GENERIC_ERROR,
1789                      (("%s")), thread_db_err_str (err));
1790
1791       /* Cast assuming host == target.  Joy.  */
1792       /* Do proper sign extension for the target.  */
1793       gdb_assert (exec_bfd);
1794       return (bfd_get_sign_extend_vma (exec_bfd) > 0
1795               ? (CORE_ADDR) (intptr_t) address
1796               : (CORE_ADDR) (uintptr_t) address);
1797     }
1798
1799   return beneath ()->get_thread_local_address (ptid, lm, offset);
1800 }
1801
1802 /* Implement the to_get_ada_task_ptid target method for this target.  */
1803
1804 ptid_t
1805 thread_db_target::get_ada_task_ptid (long lwp, long thread)
1806 {
1807   /* NPTL uses a 1:1 model, so the LWP id suffices.  */
1808   return ptid_t (inferior_ptid.pid (), lwp, 0);
1809 }
1810
1811 void
1812 thread_db_target::resume (ptid_t ptid, int step, enum gdb_signal signo)
1813 {
1814   struct thread_db_info *info;
1815
1816   if (ptid == minus_one_ptid)
1817     info = get_thread_db_info (inferior_ptid.pid ());
1818   else
1819     info = get_thread_db_info (ptid.pid ());
1820
1821   /* This workaround is only needed for child fork lwps stopped in a
1822      PTRACE_O_TRACEFORK event.  When the inferior is resumed, the
1823      workaround can be disabled.  */
1824   if (info)
1825     info->need_stale_parent_threads_check = 0;
1826
1827   beneath ()->resume (ptid, step, signo);
1828 }
1829
1830 /* std::sort helper function for info_auto_load_libthread_db, sort the
1831    thread_db_info pointers primarily by their FILENAME and secondarily by their
1832    PID, both in ascending order.  */
1833
1834 static bool
1835 info_auto_load_libthread_db_compare (const struct thread_db_info *a,
1836                                      const struct thread_db_info *b)
1837 {
1838   int retval;
1839
1840   retval = strcmp (a->filename, b->filename);
1841   if (retval)
1842     return retval < 0;
1843
1844   return a->pid < b->pid;
1845 }
1846
1847 /* Implement 'info auto-load libthread-db'.  */
1848
1849 static void
1850 info_auto_load_libthread_db (const char *args, int from_tty)
1851 {
1852   struct ui_out *uiout = current_uiout;
1853   const char *cs = args ? args : "";
1854   struct thread_db_info *info;
1855   unsigned unique_filenames;
1856   size_t max_filename_len, pids_len;
1857   int i;
1858
1859   cs = skip_spaces (cs);
1860   if (*cs)
1861     error (_("'info auto-load libthread-db' does not accept any parameters"));
1862
1863   std::vector<struct thread_db_info *> array;
1864   for (info = thread_db_list; info; info = info->next)
1865     if (info->filename != NULL)
1866       array.push_back (info);
1867
1868   /* Sort ARRAY by filenames and PIDs.  */
1869   std::sort (array.begin (), array.end (),
1870              info_auto_load_libthread_db_compare);
1871
1872   /* Calculate the number of unique filenames (rows) and the maximum string
1873      length of PIDs list for the unique filenames (columns).  */
1874
1875   unique_filenames = 0;
1876   max_filename_len = 0;
1877   pids_len = 0;
1878   for (i = 0; i < array.size (); i++)
1879     {
1880       int pid = array[i]->pid;
1881       size_t this_pid_len;
1882
1883       for (this_pid_len = 0; pid != 0; pid /= 10)
1884         this_pid_len++;
1885
1886       if (i == 0 || strcmp (array[i - 1]->filename, array[i]->filename) != 0)
1887         {
1888           unique_filenames++;
1889           max_filename_len = std::max (max_filename_len,
1890                                        strlen (array[i]->filename));
1891
1892           if (i > 0)
1893             pids_len -= strlen (", ");
1894           pids_len = 0;
1895         }
1896       pids_len += this_pid_len + strlen (", ");
1897     }
1898   if (i)
1899     pids_len -= strlen (", ");
1900
1901   /* Table header shifted right by preceding "libthread-db:  " would not match
1902      its columns.  */
1903   if (array.size () > 0 && args == auto_load_info_scripts_pattern_nl)
1904     uiout->text ("\n");
1905
1906   {
1907     ui_out_emit_table table_emitter (uiout, 2, unique_filenames,
1908                                      "LinuxThreadDbTable");
1909
1910     uiout->table_header (max_filename_len, ui_left, "filename", "Filename");
1911     uiout->table_header (pids_len, ui_left, "PIDs", "Pids");
1912     uiout->table_body ();
1913
1914     /* Note I is incremented inside the cycle, not at its end.  */
1915     for (i = 0; i < array.size ();)
1916       {
1917         ui_out_emit_tuple tuple_emitter (uiout, NULL);
1918
1919         info = array[i];
1920         uiout->field_string ("filename", info->filename);
1921
1922         std::string pids;
1923         while (i < array.size () && strcmp (info->filename,
1924                                             array[i]->filename) == 0)
1925           {
1926             if (!pids.empty ())
1927               pids += ", ";
1928             string_appendf (pids, "%u", array[i]->pid);
1929             i++;
1930           }
1931
1932         uiout->field_string ("pids", pids.c_str ());
1933
1934         uiout->text ("\n");
1935       }
1936   }
1937
1938   if (array.empty ())
1939     uiout->message (_("No auto-loaded libthread-db.\n"));
1940 }
1941
1942 /* Implement 'maintenance check libthread-db'.  */
1943
1944 static void
1945 maintenance_check_libthread_db (const char *args, int from_tty)
1946 {
1947   int inferior_pid = inferior_ptid.pid ();
1948   struct thread_db_info *info;
1949
1950   if (inferior_pid == 0)
1951     error (_("No inferior running"));
1952
1953   info = get_thread_db_info (inferior_pid);
1954   if (info == NULL)
1955     error (_("No libthread_db loaded"));
1956
1957   check_thread_db (info, true);
1958 }
1959
1960 void
1961 _initialize_thread_db (void)
1962 {
1963   /* Defer loading of libthread_db.so until inferior is running.
1964      This allows gdb to load correct libthread_db for a given
1965      executable -- there could be multiple versions of glibc,
1966      and until there is a running inferior, we can't tell which
1967      libthread_db is the correct one to load.  */
1968
1969   libthread_db_search_path = xstrdup (LIBTHREAD_DB_SEARCH_PATH);
1970
1971   add_setshow_optional_filename_cmd ("libthread-db-search-path",
1972                                      class_support,
1973                                      &libthread_db_search_path, _("\
1974 Set search path for libthread_db."), _("\
1975 Show the current search path or libthread_db."), _("\
1976 This path is used to search for libthread_db to be loaded into \
1977 gdb itself.\n\
1978 Its value is a colon (':') separate list of directories to search.\n\
1979 Setting the search path to an empty list resets it to its default value."),
1980                             set_libthread_db_search_path,
1981                             NULL,
1982                             &setlist, &showlist);
1983
1984   add_setshow_zuinteger_cmd ("libthread-db", class_maintenance,
1985                              &libthread_db_debug, _("\
1986 Set libthread-db debugging."), _("\
1987 Show libthread-db debugging."), _("\
1988 When non-zero, libthread-db debugging is enabled."),
1989                              NULL,
1990                              show_libthread_db_debug,
1991                              &setdebuglist, &showdebuglist);
1992
1993   add_setshow_boolean_cmd ("libthread-db", class_support,
1994                            &auto_load_thread_db, _("\
1995 Enable or disable auto-loading of inferior specific libthread_db."), _("\
1996 Show whether auto-loading inferior specific libthread_db is enabled."), _("\
1997 If enabled, libthread_db will be searched in 'set libthread-db-search-path'\n\
1998 locations to load libthread_db compatible with the inferior.\n\
1999 Standard system libthread_db still gets loaded even with this option off.\n\
2000 This option has security implications for untrusted inferiors."),
2001                            NULL, show_auto_load_thread_db,
2002                            auto_load_set_cmdlist_get (),
2003                            auto_load_show_cmdlist_get ());
2004
2005   add_cmd ("libthread-db", class_info, info_auto_load_libthread_db,
2006            _("Print the list of loaded inferior specific libthread_db.\n\
2007 Usage: info auto-load libthread-db"),
2008            auto_load_info_cmdlist_get ());
2009
2010   add_cmd ("libthread-db", class_maintenance,
2011            maintenance_check_libthread_db, _("\
2012 Run integrity checks on the current inferior's libthread_db."),
2013            &maintenancechecklist);
2014
2015   add_setshow_boolean_cmd ("check-libthread-db",
2016                            class_maintenance,
2017                            &check_thread_db_on_load, _("\
2018 Set whether to check libthread_db at load time."), _("\
2019 Show whether to check libthread_db at load time."), _("\
2020 If enabled GDB will run integrity checks on inferior specific libthread_db\n\
2021 as they are loaded."),
2022                            NULL,
2023                            NULL,
2024                            &maintenance_set_cmdlist,
2025                            &maintenance_show_cmdlist);
2026
2027   /* Add ourselves to objfile event chain.  */
2028   gdb::observers::new_objfile.attach (thread_db_new_objfile);
2029
2030   /* Add ourselves to inferior_created event chain.
2031      This is needed to handle debugging statically linked programs where
2032      the new_objfile observer won't get called for libpthread.  */
2033   gdb::observers::inferior_created.attach (thread_db_inferior_created);
2034 }