1 /* libthread_db assisted debugging support, generic parts.
3 Copyright (C) 1999-2021 Free Software Foundation, Inc.
5 This file is part of GDB.
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.
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.
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/>. */
22 #include "gdb_proc_service.h"
23 #include "nat/gdb_thread_db.h"
24 #include "gdbsupport/gdb_vecs.h"
28 #include "gdbthread.h"
36 #include "solib-svr4.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"
47 #include "nat/linux-namespaces.h"
49 #include "gdbsupport/pathstuff.h"
51 #include "cli/cli-style.h"
53 /* GNU/Linux libthread_db support.
55 libthread_db is a library, provided along with libpthread.so, which
56 exposes the internals of the thread library to a debugger. It
57 allows GDB to find existing threads, new threads as they are
58 created, thread IDs (usually, the result of pthread_self), and
59 thread-local variables.
61 The libthread_db interface originates on Solaris, where it is both
62 more powerful and more complicated. This implementation only works
63 for NPTL, the glibc threading library. It assumes that each thread
64 is permanently assigned to a single light-weight process (LWP). At
65 some point it also supported the older LinuxThreads library, but it
68 libthread_db-specific information is stored in the "private" field
69 of struct thread_info. When the field is NULL we do not yet have
70 information about the new thread; this could be temporary (created,
71 but the thread library's data structures do not reflect it yet)
72 or permanent (created using clone instead of pthread_create).
74 Process IDs managed by linux-thread-db.c match those used by
75 linux-nat.c: a common PID for all processes, an LWP ID for each
76 thread, and no TID. We save the TID in private. Keeping it out
77 of the ptid_t prevents thread IDs changing when libpthread is
78 loaded or unloaded. */
80 static const target_info thread_db_target_info
= {
82 N_("multi-threaded child process."),
83 N_("Threads and pthreads support.")
86 class thread_db_target final
: public target_ops
89 const target_info
&info () const override
90 { return thread_db_target_info
; }
92 strata
stratum () const override
{ return thread_stratum
; }
94 void detach (inferior
*, int) override
;
95 ptid_t
wait (ptid_t
, struct target_waitstatus
*, target_wait_flags
) override
;
96 void resume (ptid_t
, int, enum gdb_signal
) override
;
97 void mourn_inferior () override
;
98 void follow_exec (inferior
*, ptid_t
, const char *) override
;
99 void update_thread_list () override
;
100 std::string
pid_to_str (ptid_t
) override
;
101 CORE_ADDR
get_thread_local_address (ptid_t ptid
,
102 CORE_ADDR load_module_addr
,
103 CORE_ADDR offset
) override
;
104 const char *extra_thread_info (struct thread_info
*) override
;
105 ptid_t
get_ada_task_ptid (long lwp
, ULONGEST thread
) override
;
107 thread_info
*thread_handle_to_thread_info (const gdb_byte
*thread_handle
,
109 inferior
*inf
) override
;
110 gdb::byte_vector
thread_info_to_thread_handle (struct thread_info
*) override
;
113 static std::string libthread_db_search_path
= LIBTHREAD_DB_SEARCH_PATH
;
115 /* Set to true if thread_db auto-loading is enabled
116 by the "set auto-load libthread-db" command. */
117 static bool auto_load_thread_db
= true;
119 /* Set to true if load-time libthread_db tests have been enabled
120 by the "maintenance set check-libthread-db" command. */
121 static bool check_thread_db_on_load
= false;
123 /* "show" command for the auto_load_thread_db configuration variable. */
126 show_auto_load_thread_db (struct ui_file
*file
, int from_tty
,
127 struct cmd_list_element
*c
, const char *value
)
129 fprintf_filtered (file
, _("Auto-loading of inferior specific libthread_db "
135 set_libthread_db_search_path (const char *ignored
, int from_tty
,
136 struct cmd_list_element
*c
)
138 if (libthread_db_search_path
.empty ())
139 libthread_db_search_path
= LIBTHREAD_DB_SEARCH_PATH
;
142 /* If non-zero, print details of libthread_db processing. */
144 static unsigned int libthread_db_debug
;
147 show_libthread_db_debug (struct ui_file
*file
, int from_tty
,
148 struct cmd_list_element
*c
, const char *value
)
150 fprintf_filtered (file
, _("libthread-db debugging is %s.\n"), value
);
153 /* If we're running on GNU/Linux, we must explicitly attach to any new
156 /* This module's target vector. */
157 static thread_db_target the_thread_db_target
;
159 /* Non-zero if we have determined the signals used by the threads
161 static int thread_signals
;
163 struct thread_db_info
165 struct thread_db_info
*next
;
167 /* The target this thread_db_info is bound to. */
168 process_stratum_target
*process_target
;
170 /* Process id this object refers to. */
173 /* Handle from dlopen for libthread_db.so. */
176 /* Absolute pathname from gdb_realpath to disk file used for dlopen-ing
177 HANDLE. It may be NULL for system library. */
180 /* Structure that identifies the child process for the
181 <proc_service.h> interface. */
182 struct ps_prochandle proc_handle
;
184 /* Connection to the libthread_db library. */
185 td_thragent_t
*thread_agent
;
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
;
194 /* Pointers to the libthread_db functions. */
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
;
206 /* List of known processes using thread_db, and the required
208 static thread_db_info
*thread_db_list
;
210 static void thread_db_find_new_threads_1 (thread_info
*stopped
);
211 static void thread_db_find_new_threads_2 (thread_info
*stopped
,
214 static void check_thread_signals (void);
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
);
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
225 static struct thread_db_info
*
226 add_thread_db_info (void *handle
)
228 struct thread_db_info
*info
= XCNEW (struct thread_db_info
);
230 info
->process_target
= current_inferior ()->process_target ();
231 info
->pid
= inferior_ptid
.pid ();
232 info
->handle
= handle
;
234 /* The workaround works by reading from /proc/pid/status, so it is
235 disabled for core files. */
236 if (target_has_execution ())
237 info
->need_stale_parent_threads_check
= 1;
239 info
->next
= thread_db_list
;
240 thread_db_list
= info
;
245 /* Return the thread_db_info object representing the bookkeeping
246 related to process PID, if any; NULL otherwise. */
248 static struct thread_db_info
*
249 get_thread_db_info (process_stratum_target
*targ
, int pid
)
251 struct thread_db_info
*info
;
253 for (info
= thread_db_list
; info
; info
= info
->next
)
254 if (targ
== info
->process_target
&& pid
== info
->pid
)
260 static const char *thread_db_err_str (td_err_e err
);
262 /* When PID has exited or has been detached, we no longer want to keep
263 track of it as using libpthread. Call this function to discard
264 thread_db related info related to PID. Note that this closes
265 LIBTHREAD_DB_SO's dlopen'ed handle. */
268 delete_thread_db_info (process_stratum_target
*targ
, int pid
)
270 struct thread_db_info
*info
, *info_prev
;
274 for (info
= thread_db_list
; info
; info_prev
= info
, info
= info
->next
)
275 if (targ
== info
->process_target
&& pid
== info
->pid
)
281 if (info
->thread_agent
!= NULL
&& info
->td_ta_delete_p
!= NULL
)
283 td_err_e err
= info
->td_ta_delete_p (info
->thread_agent
);
286 warning (_("Cannot deregister process %d from libthread_db: %s"),
287 pid
, thread_db_err_str (err
));
288 info
->thread_agent
= NULL
;
291 if (info
->handle
!= NULL
)
292 dlclose (info
->handle
);
294 xfree (info
->filename
);
297 info_prev
->next
= info
->next
;
299 thread_db_list
= info
->next
;
304 /* Use "struct private_thread_info" to cache thread state. This is
305 a substantial optimization. */
307 struct thread_db_thread_info
: public private_thread_info
309 /* Flag set when we see a TD_DEATH event for this thread. */
312 /* Cached thread state. */
313 td_thrhandle_t th
{};
317 static thread_db_thread_info
*
318 get_thread_db_thread_info (thread_info
*thread
)
320 return static_cast<thread_db_thread_info
*> (thread
->priv
.get ());
324 thread_db_err_str (td_err_e err
)
331 return "generic 'call succeeded'";
333 return "generic error";
335 return "no thread to satisfy query";
337 return "no sync handle to satisfy query";
339 return "no LWP to satisfy query";
341 return "invalid process handle";
343 return "invalid thread handle";
345 return "invalid synchronization handle";
347 return "invalid thread agent";
349 return "invalid key";
351 return "no event message for getmsg";
353 return "FPU register set not available";
355 return "application not linked with libthread";
357 return "requested event is not supported";
359 return "capability not available";
361 return "debugger service failed";
363 return "operation not applicable to";
365 return "no thread-specific data for this thread";
367 return "malloc failed";
369 return "only part of register set was written/read";
371 return "X register set not available for this thread";
372 #ifdef THREAD_DB_HAS_TD_NOTALLOC
374 return "thread has not yet allocated TLS for given module";
376 #ifdef THREAD_DB_HAS_TD_VERSION
378 return "versions of libpthread and libthread_db do not match";
380 #ifdef THREAD_DB_HAS_TD_NOTLS
382 return "there is no TLS segment in the given module";
385 snprintf (buf
, sizeof (buf
), "unknown thread_db error '%d'", err
);
390 /* Fetch the user-level thread id of PTID. STOPPED is a stopped
391 thread that we can use to access memory. */
393 static struct thread_info
*
394 thread_from_lwp (thread_info
*stopped
, ptid_t ptid
)
399 struct thread_db_info
*info
;
400 struct thread_info
*tp
;
402 /* Just in case td_ta_map_lwp2thr doesn't initialize it completely. */
405 /* This ptid comes from linux-nat.c, which should always fill in the
407 gdb_assert (ptid
.lwp () != 0);
409 info
= get_thread_db_info (stopped
->inf
->process_target (), ptid
.pid ());
411 /* Access an lwp we know is stopped. */
412 info
->proc_handle
.thread
= stopped
;
413 err
= info
->td_ta_map_lwp2thr_p (info
->thread_agent
, ptid
.lwp (),
416 error (_("Cannot find user-level thread for LWP %ld: %s"),
417 ptid
.lwp (), thread_db_err_str (err
));
419 err
= info
->td_thr_get_info_p (&th
, &ti
);
421 error (_("thread_get_info_callback: cannot get thread info: %s"),
422 thread_db_err_str (err
));
424 /* Fill the cache. */
425 tp
= find_thread_ptid (stopped
->inf
->process_target (), ptid
);
426 return record_thread (info
, tp
, ptid
, &th
, &ti
);
430 /* See linux-nat.h. */
433 thread_db_notice_clone (ptid_t parent
, ptid_t child
)
435 struct thread_db_info
*info
;
437 info
= get_thread_db_info (linux_target
, child
.pid ());
442 thread_info
*stopped
= find_thread_ptid (linux_target
, parent
);
444 thread_from_lwp (stopped
, child
);
446 /* If we do not know about the main thread's pthread info yet, this
447 would be a good time to find it. */
448 thread_from_lwp (stopped
, parent
);
453 verbose_dlsym (void *handle
, const char *name
)
455 void *sym
= dlsym (handle
, name
);
457 warning (_("Symbol \"%s\" not found in libthread_db: %s"),
462 /* Verify inferior's '\0'-terminated symbol VER_SYMBOL starts with "%d.%d" and
463 return 1 if this version is lower (and not equal) to
464 VER_MAJOR_MIN.VER_MINOR_MIN. Return 0 in all other cases. */
467 inferior_has_bug (const char *ver_symbol
, int ver_major_min
, int ver_minor_min
)
469 struct bound_minimal_symbol version_msym
;
470 CORE_ADDR version_addr
;
473 version_msym
= lookup_minimal_symbol (ver_symbol
, NULL
, NULL
);
474 if (version_msym
.minsym
== NULL
)
477 version_addr
= BMSYMBOL_VALUE_ADDRESS (version_msym
);
478 gdb::unique_xmalloc_ptr
<char> version
479 = target_read_string (version_addr
, 32, &got
);
480 if (version
!= nullptr
481 && memchr (version
.get (), 0, got
) == version
.get () + got
- 1)
485 retval
= (sscanf (version
.get (), "%d.%d", &major
, &minor
) == 2
486 && (major
< ver_major_min
487 || (major
== ver_major_min
&& minor
< ver_minor_min
)));
493 /* Similar as thread_db_find_new_threads_1, but try to silently ignore errors
496 Return 1 if the caller should abort libthread_db initialization. Return 0
500 thread_db_find_new_threads_silently (thread_info
*stopped
)
505 thread_db_find_new_threads_2 (stopped
, true);
508 catch (const gdb_exception_error
&except
)
510 if (libthread_db_debug
)
511 exception_fprintf (gdb_stdlog
, except
,
512 "Warning: thread_db_find_new_threads_silently: ");
514 /* There is a bug fixed between nptl 2.6.1 and 2.7 by
515 commit 7d9d8bd18906fdd17364f372b160d7ab896ce909
516 where calls to td_thr_get_info fail with TD_ERR for statically linked
517 executables if td_thr_get_info is called before glibc has initialized
520 If the nptl bug is NOT present in the inferior and still thread_db
521 reports an error return 1. It means the inferior has corrupted thread
522 list and GDB should fall back only to LWPs.
524 If the nptl bug is present in the inferior return 0 to silently ignore
525 such errors, and let gdb enumerate threads again later. In such case
526 GDB cannot properly display LWPs if the inferior thread list is
527 corrupted. For core files it does not apply, no 'later enumeration'
530 if (!target_has_execution () || !inferior_has_bug ("nptl_version", 2, 7))
532 exception_fprintf (gdb_stderr
, except
,
533 _("Warning: couldn't activate thread debugging "
534 "using libthread_db: "));
542 /* Lookup a library in which given symbol resides.
543 Note: this is looking in GDB process, not in the inferior.
544 Returns library name, or NULL. */
547 dladdr_to_soname (const void *addr
)
551 if (dladdr (addr
, &info
) != 0)
552 return info
.dli_fname
;
556 /* State for check_thread_db_callback. */
558 struct check_thread_db_info
560 /* The libthread_db under test. */
561 struct thread_db_info
*info
;
563 /* True if progress should be logged. */
566 /* True if the callback was called. */
569 /* Name of last libthread_db function called. */
570 const char *last_call
;
572 /* Value returned by last libthread_db call. */
573 td_err_e last_result
;
576 static struct check_thread_db_info
*tdb_testinfo
;
578 /* Callback for check_thread_db. */
581 check_thread_db_callback (const td_thrhandle_t
*th
, void *arg
)
583 gdb_assert (tdb_testinfo
!= NULL
);
584 tdb_testinfo
->threads_seen
= true;
586 #define LOG(fmt, args...) \
589 if (tdb_testinfo->log_progress) \
591 debug_printf (fmt, ## args); \
592 gdb_flush (gdb_stdlog); \
597 #define CHECK_1(expr, args...) \
602 LOG (" ... FAIL!\n"); \
608 #define CHECK(expr) \
609 CHECK_1 (expr, "(%s) == false", #expr)
611 #define CALL_UNCHECKED(func, args...) \
614 tdb_testinfo->last_call = #func; \
615 tdb_testinfo->last_result \
616 = tdb_testinfo->info->func ## _p (args); \
620 #define CHECK_CALL() \
621 CHECK_1 (tdb_testinfo->last_result == TD_OK, \
622 _("%s failed: %s"), \
623 tdb_testinfo->last_call, \
624 thread_db_err_str (tdb_testinfo->last_result)) \
626 #define CALL(func, args...) \
629 CALL_UNCHECKED (func, args); \
636 /* Check td_ta_thr_iter passed consistent arguments. */
638 CHECK (arg
== (void *) tdb_testinfo
);
639 CHECK (th
->th_ta_p
== tdb_testinfo
->info
->thread_agent
);
641 LOG (" %s", core_addr_to_string_nz ((CORE_ADDR
) th
->th_unique
));
643 /* Check td_thr_get_info. */
645 CALL (td_thr_get_info
, th
, &ti
);
647 LOG (" => %d", ti
.ti_lid
);
649 CHECK (ti
.ti_ta_p
== th
->th_ta_p
);
650 CHECK (ti
.ti_tid
== (thread_t
) th
->th_unique
);
652 /* Check td_ta_map_lwp2thr. */
654 memset (&th2
, 23, sizeof (td_thrhandle_t
));
655 CALL_UNCHECKED (td_ta_map_lwp2thr
, th
->th_ta_p
, ti
.ti_lid
, &th2
);
657 if (tdb_testinfo
->last_result
== TD_ERR
&& !target_has_execution ())
659 /* Some platforms require execution for td_ta_map_lwp2thr. */
660 LOG (_("; can't map_lwp2thr"));
666 LOG (" => %s", core_addr_to_string_nz ((CORE_ADDR
) th2
.th_unique
));
668 CHECK (memcmp (th
, &th2
, sizeof (td_thrhandle_t
)) == 0);
671 /* Attempt TLS access. Assuming errno is TLS, this calls
672 thread_db_get_thread_local_address, which in turn calls
673 td_thr_tls_get_addr for live inferiors or td_thr_tlsbase
674 for core files. This test is skipped if the thread has
675 not been recorded; proceeding in that case would result
676 in the test having the side-effect of noticing threads
679 Note that in glibc's libthread_db td_thr_tls_get_addr is
680 a thin wrapper around td_thr_tlsbase; this check always
681 hits the bulk of the code.
683 Note also that we don't actually check any libthread_db
684 calls are made, we just assume they were; future changes
685 to how GDB accesses TLS could result in this passing
686 without exercising the calls it's supposed to. */
687 ptid_t ptid
= ptid_t (tdb_testinfo
->info
->pid
, ti
.ti_lid
);
688 thread_info
*thread_info
= find_thread_ptid (linux_target
, ptid
);
689 if (thread_info
!= NULL
&& thread_info
->priv
!= NULL
)
693 scoped_restore_current_thread restore_current_thread
;
694 switch_to_thread (thread_info
);
696 expression_up expr
= parse_expression ("(int) errno");
697 struct value
*val
= evaluate_expression (expr
.get ());
699 if (tdb_testinfo
->log_progress
)
701 struct value_print_options opts
;
703 get_user_print_options (&opts
);
705 value_print (val
, gdb_stdlog
, &opts
);
714 #undef CALL_UNCHECKED
721 /* Run integrity checks on the dlopen()ed libthread_db described by
722 INFO. Returns true on success, displays a warning and returns
723 false on failure. Logs progress messages to gdb_stdlog during
724 the test if LOG_PROGRESS is true. */
727 check_thread_db (struct thread_db_info
*info
, bool log_progress
)
729 bool test_passed
= true;
732 debug_printf (_("Running libthread_db integrity checks:\n"));
734 /* GDB avoids using td_ta_thr_iter wherever possible (see comment
735 in try_thread_db_load_1 below) so in order to test it we may
736 have to locate it ourselves. */
737 td_ta_thr_iter_ftype
*td_ta_thr_iter_p
= info
->td_ta_thr_iter_p
;
738 if (td_ta_thr_iter_p
== NULL
)
740 void *thr_iter
= verbose_dlsym (info
->handle
, "td_ta_thr_iter");
741 if (thr_iter
== NULL
)
744 td_ta_thr_iter_p
= (td_ta_thr_iter_ftype
*) thr_iter
;
747 /* Set up the test state we share with the callback. */
748 gdb_assert (tdb_testinfo
== NULL
);
749 struct check_thread_db_info tdb_testinfo_buf
;
750 tdb_testinfo
= &tdb_testinfo_buf
;
752 memset (tdb_testinfo
, 0, sizeof (struct check_thread_db_info
));
753 tdb_testinfo
->info
= info
;
754 tdb_testinfo
->log_progress
= log_progress
;
756 /* td_ta_thr_iter shouldn't be used on running processes. Note that
757 it's possible the inferior will stop midway through modifying one
758 of its thread lists, in which case the check will spuriously
760 linux_stop_and_wait_all_lwps ();
764 td_err_e err
= td_ta_thr_iter_p (info
->thread_agent
,
765 check_thread_db_callback
,
768 TD_THR_LOWEST_PRIORITY
,
770 TD_THR_ANY_USER_FLAGS
);
773 error (_("td_ta_thr_iter failed: %s"), thread_db_err_str (err
));
775 if (!tdb_testinfo
->threads_seen
)
776 error (_("no threads seen"));
778 catch (const gdb_exception_error
&except
)
780 if (warning_pre_print
)
781 fputs_unfiltered (warning_pre_print
, gdb_stderr
);
783 exception_fprintf (gdb_stderr
, except
,
784 _("libthread_db integrity checks failed: "));
789 if (test_passed
&& log_progress
)
790 debug_printf (_("libthread_db integrity checks passed.\n"));
794 linux_unstop_all_lwps ();
799 /* Predicate which tests whether objfile OBJ refers to the library
800 containing pthread related symbols. Historically, this library has
801 been named in such a way that looking for "libpthread" in the name
802 was sufficient to identify it. As of glibc-2.34, the C library
803 (libc) contains the thread library symbols. Therefore we check
804 that the name matches a possible thread library, but we also check
805 that it contains at least one of the symbols (pthread_create) that
806 we'd expect to find in the thread library. */
809 libpthread_objfile_p (objfile
*obj
)
811 return (libpthread_name_p (objfile_name (obj
))
812 && lookup_minimal_symbol ("pthread_create",
814 obj
).minsym
!= NULL
);
817 /* Attempt to initialize dlopen()ed libthread_db, described by INFO.
818 Return true on success.
819 Failure could happen if libthread_db does not have symbols we expect,
820 or when it refuses to work with the current inferior (e.g. due to
821 version mismatch between libthread_db and libpthread). */
824 try_thread_db_load_1 (struct thread_db_info
*info
)
828 /* Initialize pointers to the dynamic library functions we will use.
829 Essential functions first. */
831 #define TDB_VERBOSE_DLSYM(info, func) \
832 info->func ## _p = (func ## _ftype *) verbose_dlsym (info->handle, #func)
834 #define TDB_DLSYM(info, func) \
835 info->func ## _p = (func ## _ftype *) dlsym (info->handle, #func)
844 CHK (TDB_VERBOSE_DLSYM (info
, td_init
));
846 err
= info
->td_init_p ();
849 warning (_("Cannot initialize libthread_db: %s"),
850 thread_db_err_str (err
));
854 CHK (TDB_VERBOSE_DLSYM (info
, td_ta_new
));
856 /* Initialize the structure that identifies the child process. */
857 info
->proc_handle
.thread
= inferior_thread ();
859 /* Now attempt to open a connection to the thread library. */
860 err
= info
->td_ta_new_p (&info
->proc_handle
, &info
->thread_agent
);
863 if (libthread_db_debug
)
864 fprintf_unfiltered (gdb_stdlog
, _("td_ta_new failed: %s\n"),
865 thread_db_err_str (err
));
870 #ifdef THREAD_DB_HAS_TD_VERSION
873 /* The errors above are not unexpected and silently ignored:
874 they just mean we haven't found correct version of
878 warning (_("td_ta_new failed: %s"), thread_db_err_str (err
));
883 /* These are essential. */
884 CHK (TDB_VERBOSE_DLSYM (info
, td_ta_map_lwp2thr
));
885 CHK (TDB_VERBOSE_DLSYM (info
, td_thr_get_info
));
887 /* These are not essential. */
888 TDB_DLSYM (info
, td_thr_tls_get_addr
);
889 TDB_DLSYM (info
, td_thr_tlsbase
);
890 TDB_DLSYM (info
, td_ta_delete
);
892 /* It's best to avoid td_ta_thr_iter if possible. That walks data
893 structures in the inferior's address space that may be corrupted,
894 or, if the target is running, may change while we walk them. If
895 there's execution (and /proc is mounted), then we're already
896 attached to all LWPs. Use thread_from_lwp, which uses
897 td_ta_map_lwp2thr instead, which does not walk the thread list.
899 td_ta_map_lwp2thr uses ps_get_thread_area, but we can't use that
900 currently on core targets, as it uses ptrace directly. */
901 if (target_has_execution ()
902 && linux_proc_task_list_dir_exists (inferior_ptid
.pid ()))
903 info
->td_ta_thr_iter_p
= NULL
;
905 CHK (TDB_VERBOSE_DLSYM (info
, td_ta_thr_iter
));
907 #undef TDB_VERBOSE_DLSYM
911 /* Run integrity checks if requested. */
912 if (check_thread_db_on_load
)
914 if (!check_thread_db (info
, libthread_db_debug
))
918 if (info
->td_ta_thr_iter_p
== NULL
)
920 int pid
= inferior_ptid
.pid ();
921 thread_info
*curr_thread
= inferior_thread ();
923 linux_stop_and_wait_all_lwps ();
925 for (const lwp_info
*lp
: all_lwps ())
926 if (lp
->ptid
.pid () == pid
)
927 thread_from_lwp (curr_thread
, lp
->ptid
);
929 linux_unstop_all_lwps ();
931 else if (thread_db_find_new_threads_silently (inferior_thread ()) != 0)
933 /* Even if libthread_db initializes, if the thread list is
934 corrupted, we'd not manage to list any threads. Better reject this
935 thread_db, and fall back to at least listing LWPs. */
939 printf_unfiltered (_("[Thread debugging using libthread_db enabled]\n"));
941 if (!libthread_db_search_path
.empty () || libthread_db_debug
)
943 struct ui_file
*file
;
946 library
= dladdr_to_soname ((const void *) *info
->td_ta_new_p
);
948 library
= LIBTHREAD_DB_SO
;
950 /* If we'd print this to gdb_stdout when debug output is
951 disabled, still print it to gdb_stdout if debug output is
952 enabled. User visible output should not depend on debug
954 file
= !libthread_db_search_path
.empty () ? gdb_stdout
: gdb_stdlog
;
955 fprintf_unfiltered (file
,
956 _("Using host libthread_db library \"%ps\".\n"),
957 styled_string (file_name_style
.style (), library
));
960 /* The thread library was detected. Activate the thread_db target
962 current_inferior ()->push_target (&the_thread_db_target
);
966 /* Attempt to use LIBRARY as libthread_db. LIBRARY could be absolute,
967 relative, or just LIBTHREAD_DB. */
970 try_thread_db_load (const char *library
, bool check_auto_load_safe
)
973 struct thread_db_info
*info
;
975 if (libthread_db_debug
)
976 fprintf_unfiltered (gdb_stdlog
,
977 _("Trying host libthread_db library: %s.\n"),
980 if (check_auto_load_safe
)
982 if (access (library
, R_OK
) != 0)
984 /* Do not print warnings by file_is_auto_load_safe if the library does
985 not exist at this place. */
986 if (libthread_db_debug
)
987 fprintf_unfiltered (gdb_stdlog
, _("open failed: %s.\n"),
988 safe_strerror (errno
));
992 auto_load_debug_printf
993 ("Loading libthread-db library \"%s\" from explicit directory.",
996 if (!file_is_auto_load_safe (library
))
1000 handle
= dlopen (library
, RTLD_NOW
);
1003 if (libthread_db_debug
)
1004 fprintf_unfiltered (gdb_stdlog
, _("dlopen failed: %s.\n"), dlerror ());
1008 if (libthread_db_debug
&& strchr (library
, '/') == NULL
)
1012 td_init
= dlsym (handle
, "td_init");
1013 if (td_init
!= NULL
)
1015 const char *const libpath
= dladdr_to_soname (td_init
);
1017 if (libpath
!= NULL
)
1018 fprintf_unfiltered (gdb_stdlog
, _("Host %s resolved to: %s.\n"),
1023 info
= add_thread_db_info (handle
);
1025 /* Do not save system library name, that one is always trusted. */
1026 if (strchr (library
, '/') != NULL
)
1027 info
->filename
= gdb_realpath (library
).release ();
1031 if (try_thread_db_load_1 (info
))
1034 catch (const gdb_exception_error
&except
)
1036 if (libthread_db_debug
)
1037 exception_fprintf (gdb_stdlog
, except
,
1038 "Warning: While trying to load libthread_db: ");
1041 /* This library "refused" to work on current inferior. */
1042 delete_thread_db_info (current_inferior ()->process_target (),
1043 inferior_ptid
.pid ());
1047 /* Subroutine of try_thread_db_load_from_pdir to simplify it.
1048 Try loading libthread_db in directory(OBJ)/SUBDIR.
1049 SUBDIR may be NULL. It may also be something like "../lib64".
1050 The result is true for success. */
1053 try_thread_db_load_from_pdir_1 (struct objfile
*obj
, const char *subdir
)
1055 const char *obj_name
= objfile_name (obj
);
1057 if (obj_name
[0] != '/')
1059 warning (_("Expected absolute pathname for libpthread in the"
1060 " inferior, but got %ps."),
1061 styled_string (file_name_style
.style (), obj_name
));
1065 std::string path
= obj_name
;
1066 size_t cp
= path
.rfind ('/');
1067 /* This should at minimum hit the first character. */
1068 gdb_assert (cp
!= std::string::npos
);
1069 path
.resize (cp
+ 1);
1071 path
= path
+ subdir
+ "/";
1072 path
+= LIBTHREAD_DB_SO
;
1074 return try_thread_db_load (path
.c_str (), true);
1077 /* Handle $pdir in libthread-db-search-path.
1078 Look for libthread_db in directory(libpthread)/SUBDIR.
1079 SUBDIR may be NULL. It may also be something like "../lib64".
1080 The result is true for success. */
1083 try_thread_db_load_from_pdir (const char *subdir
)
1085 if (!auto_load_thread_db
)
1088 for (objfile
*obj
: current_program_space
->objfiles ())
1089 if (libpthread_objfile_p (obj
))
1091 if (try_thread_db_load_from_pdir_1 (obj
, subdir
))
1094 /* We may have found the separate-debug-info version of
1095 libpthread, and it may live in a directory without a matching
1097 if (obj
->separate_debug_objfile_backlink
!= NULL
)
1098 return try_thread_db_load_from_pdir_1 (obj
->separate_debug_objfile_backlink
,
1107 /* Handle $sdir in libthread-db-search-path.
1108 Look for libthread_db in the system dirs, or wherever a plain
1109 dlopen(file_without_path) will look.
1110 The result is true for success. */
1113 try_thread_db_load_from_sdir (void)
1115 return try_thread_db_load (LIBTHREAD_DB_SO
, false);
1118 /* Try to load libthread_db from directory DIR of length DIR_LEN.
1119 The result is true for success. */
1122 try_thread_db_load_from_dir (const char *dir
, size_t dir_len
)
1124 if (!auto_load_thread_db
)
1127 std::string path
= std::string (dir
, dir_len
) + "/" + LIBTHREAD_DB_SO
;
1129 return try_thread_db_load (path
.c_str (), true);
1132 /* Search libthread_db_search_path for libthread_db which "agrees"
1133 to work on current inferior.
1134 The result is true for success. */
1137 thread_db_load_search (void)
1141 std::vector
<gdb::unique_xmalloc_ptr
<char>> dir_vec
1142 = dirnames_to_char_ptr_vec (libthread_db_search_path
.c_str ());
1144 for (const gdb::unique_xmalloc_ptr
<char> &this_dir_up
: dir_vec
)
1146 const char *this_dir
= this_dir_up
.get ();
1147 const int pdir_len
= sizeof ("$pdir") - 1;
1148 size_t this_dir_len
;
1150 this_dir_len
= strlen (this_dir
);
1152 if (strncmp (this_dir
, "$pdir", pdir_len
) == 0
1153 && (this_dir
[pdir_len
] == '\0'
1154 || this_dir
[pdir_len
] == '/'))
1156 const char *subdir
= NULL
;
1158 std::string subdir_holder
;
1159 if (this_dir
[pdir_len
] == '/')
1161 subdir_holder
= std::string (this_dir
+ pdir_len
+ 1);
1162 subdir
= subdir_holder
.c_str ();
1164 rc
= try_thread_db_load_from_pdir (subdir
);
1168 else if (strcmp (this_dir
, "$sdir") == 0)
1170 if (try_thread_db_load_from_sdir ())
1178 if (try_thread_db_load_from_dir (this_dir
, this_dir_len
))
1186 if (libthread_db_debug
)
1187 fprintf_unfiltered (gdb_stdlog
,
1188 _("thread_db_load_search returning %d\n"), rc
);
1192 /* Return true if the inferior has a libpthread. */
1195 has_libpthread (void)
1197 for (objfile
*obj
: current_program_space
->objfiles ())
1198 if (libpthread_objfile_p (obj
))
1204 /* Attempt to load and initialize libthread_db.
1205 Return 1 on success. */
1208 thread_db_load (void)
1210 inferior
*inf
= current_inferior ();
1212 /* When attaching / handling fork child, don't try loading libthread_db
1213 until we know about all shared libraries. */
1214 if (inf
->in_initial_library_scan
)
1217 thread_db_info
*info
= get_thread_db_info (inf
->process_target (),
1218 inferior_ptid
.pid ());
1223 /* Don't attempt to use thread_db on executables not running
1225 if (!target_has_registers ())
1228 /* Don't attempt to use thread_db for remote targets. */
1229 if (!(target_can_run () || core_bfd
))
1232 if (thread_db_load_search ())
1235 /* We couldn't find a libthread_db.
1236 If the inferior has a libpthread warn the user. */
1237 if (has_libpthread ())
1239 warning (_("Unable to find libthread_db matching inferior's thread"
1240 " library, thread debugging will not be available."));
1244 /* Either this executable isn't using libpthread at all, or it is
1245 statically linked. Since we can't easily distinguish these two cases,
1246 no warning is issued. */
1251 check_thread_signals (void)
1253 if (!thread_signals
)
1257 for (i
= 0; i
< lin_thread_get_thread_signal_num (); i
++)
1259 int sig
= lin_thread_get_thread_signal (i
);
1260 signal_stop_update (gdb_signal_from_host (sig
), 0);
1261 signal_print_update (gdb_signal_from_host (sig
), 0);
1267 /* Check whether thread_db is usable. This function is called when
1268 an inferior is created (or otherwise acquired, e.g. attached to)
1269 and when new shared libraries are loaded into a running process. */
1272 check_for_thread_db (void)
1274 /* Do nothing if we couldn't load libthread_db.so.1. */
1275 if (!thread_db_load ())
1279 /* This function is called via the new_objfile observer. */
1282 thread_db_new_objfile (struct objfile
*objfile
)
1284 /* This observer must always be called with inferior_ptid set
1288 /* libpthread with separate debug info has its debug info file already
1289 loaded (and notified without successful thread_db initialization)
1290 the time gdb::observers::new_objfile.notify is called for the library itself.
1291 Static executables have their separate debug info loaded already
1292 before the inferior has started. */
1293 && objfile
->separate_debug_objfile_backlink
== NULL
1294 /* Only check for thread_db if we loaded libpthread,
1295 or if this is the main symbol file.
1296 We need to check OBJF_MAINLINE to handle the case of debugging
1297 a statically linked executable AND the symbol file is specified AFTER
1298 the exec file is loaded (e.g., gdb -c core ; file foo).
1299 For dynamically linked executables, libpthread can be near the end
1300 of the list of shared libraries to load, and in an app of several
1301 thousand shared libraries, this can otherwise be painful. */
1302 && ((objfile
->flags
& OBJF_MAINLINE
) != 0
1303 || libpthread_objfile_p (objfile
)))
1304 check_for_thread_db ();
1308 check_pid_namespace_match (inferior
*inf
)
1310 /* Check is only relevant for local targets targets. */
1311 if (target_can_run ())
1313 /* If the child is in a different PID namespace, its idea of its
1314 PID will differ from our idea of its PID. When we scan the
1315 child's thread list, we'll mistakenly think it has no threads
1316 since the thread PID fields won't match the PID we give to
1318 if (!linux_ns_same (inf
->pid
, LINUX_NS_PID
))
1320 warning (_ ("Target and debugger are in different PID "
1321 "namespaces; thread lists and other data are "
1322 "likely unreliable. "
1323 "Connect to gdbserver inside the container."));
1328 /* This function is called via the inferior_created observer.
1329 This handles the case of debugging statically linked executables. */
1332 thread_db_inferior_created (inferior
*inf
)
1334 check_pid_namespace_match (inf
);
1335 check_for_thread_db ();
1338 /* Update the thread's state (what's displayed in "info threads"),
1339 from libthread_db thread state information. */
1342 update_thread_state (thread_db_thread_info
*priv
,
1343 const td_thrinfo_t
*ti_p
)
1345 priv
->dying
= (ti_p
->ti_state
== TD_THR_UNKNOWN
1346 || ti_p
->ti_state
== TD_THR_ZOMBIE
);
1349 /* Record a new thread in GDB's thread list. Creates the thread's
1350 private info. If TP is NULL or TP is marked as having exited,
1351 creates a new thread. Otherwise, uses TP. */
1353 static struct thread_info
*
1354 record_thread (struct thread_db_info
*info
,
1355 struct thread_info
*tp
,
1356 ptid_t ptid
, const td_thrhandle_t
*th_p
,
1357 const td_thrinfo_t
*ti_p
)
1359 /* A thread ID of zero may mean the thread library has not
1360 initialized yet. Leave private == NULL until the thread library
1362 if (ti_p
->ti_tid
== 0)
1365 /* Construct the thread's private data. */
1366 thread_db_thread_info
*priv
= new thread_db_thread_info
;
1369 priv
->tid
= ti_p
->ti_tid
;
1370 update_thread_state (priv
, ti_p
);
1372 /* Add the thread to GDB's thread list. If we already know about a
1373 thread with this PTID, but it's marked exited, then the kernel
1374 reused the tid of an old thread. */
1375 if (tp
== NULL
|| tp
->state
== THREAD_EXITED
)
1376 tp
= add_thread_with_info (info
->process_target
, ptid
, priv
);
1378 tp
->priv
.reset (priv
);
1380 if (target_has_execution ())
1381 check_thread_signals ();
1387 thread_db_target::detach (inferior
*inf
, int from_tty
)
1389 delete_thread_db_info (inf
->process_target (), inf
->pid
);
1391 beneath ()->detach (inf
, from_tty
);
1393 /* NOTE: From this point on, inferior_ptid is null_ptid. */
1395 /* Detach the thread_db target from this inferior. */
1396 inf
->unpush_target (this);
1400 thread_db_target::wait (ptid_t ptid
, struct target_waitstatus
*ourstatus
,
1401 target_wait_flags options
)
1403 struct thread_db_info
*info
;
1405 process_stratum_target
*beneath
1406 = as_process_stratum_target (this->beneath ());
1408 ptid
= beneath
->wait (ptid
, ourstatus
, options
);
1410 switch (ourstatus
->kind ())
1412 case TARGET_WAITKIND_IGNORE
:
1413 case TARGET_WAITKIND_EXITED
:
1414 case TARGET_WAITKIND_THREAD_EXITED
:
1415 case TARGET_WAITKIND_SIGNALLED
:
1416 case TARGET_WAITKIND_EXECD
:
1420 info
= get_thread_db_info (beneath
, ptid
.pid ());
1422 /* If this process isn't using thread_db, we're done. */
1426 /* Fill in the thread's user-level thread id and status. */
1427 thread_from_lwp (find_thread_ptid (beneath
, ptid
), ptid
);
1433 thread_db_target::mourn_inferior ()
1435 process_stratum_target
*target_beneath
1436 = as_process_stratum_target (this->beneath ());
1438 delete_thread_db_info (target_beneath
, inferior_ptid
.pid ());
1440 target_beneath
->mourn_inferior ();
1442 /* Detach the thread_db target from this inferior. */
1443 current_inferior ()->unpush_target (this);
1447 thread_db_target::follow_exec (inferior
*follow_inf
, ptid_t ptid
,
1448 const char *execd_pathname
)
1450 process_stratum_target
*beneath
1451 = as_process_stratum_target (this->beneath ());
1453 delete_thread_db_info (beneath
, ptid
.pid ());
1455 current_inferior ()->unpush_target (this);
1456 beneath
->follow_exec (follow_inf
, ptid
, execd_pathname
);
1459 struct callback_data
1461 struct thread_db_info
*info
;
1466 find_new_threads_callback (const td_thrhandle_t
*th_p
, void *data
)
1470 struct thread_info
*tp
;
1471 struct callback_data
*cb_data
= (struct callback_data
*) data
;
1472 struct thread_db_info
*info
= cb_data
->info
;
1474 err
= info
->td_thr_get_info_p (th_p
, &ti
);
1476 error (_("find_new_threads_callback: cannot get thread info: %s"),
1477 thread_db_err_str (err
));
1479 if (ti
.ti_lid
== -1)
1481 /* A thread with kernel thread ID -1 is either a thread that
1482 exited and was joined, or a thread that is being created but
1483 hasn't started yet, and that is reusing the tcb/stack of a
1484 thread that previously exited and was joined. (glibc marks
1485 terminated and joined threads with kernel thread ID -1. See
1487 if (libthread_db_debug
)
1488 fprintf_unfiltered (gdb_stdlog
,
1489 "thread_db: skipping exited and "
1490 "joined thread (0x%lx)\n",
1491 (unsigned long) ti
.ti_tid
);
1497 /* A thread ID of zero means that this is the main thread, but
1498 glibc has not yet initialized thread-local storage and the
1499 pthread library. We do not know what the thread's TID will
1502 /* In that case, we're not stopped in a fork syscall and don't
1503 need this glibc bug workaround. */
1504 info
->need_stale_parent_threads_check
= 0;
1509 /* Ignore stale parent threads, caused by glibc/BZ5983. This is a
1510 bit expensive, as it needs to open /proc/pid/status, so try to
1511 avoid doing the work if we know we don't have to. */
1512 if (info
->need_stale_parent_threads_check
)
1514 int tgid
= linux_proc_get_tgid (ti
.ti_lid
);
1516 if (tgid
!= -1 && tgid
!= info
->pid
)
1520 ptid_t
ptid (info
->pid
, ti
.ti_lid
);
1521 tp
= find_thread_ptid (info
->process_target
, ptid
);
1522 if (tp
== NULL
|| tp
->priv
== NULL
)
1523 record_thread (info
, tp
, ptid
, th_p
, &ti
);
1528 /* Helper for thread_db_find_new_threads_2.
1529 Returns number of new threads found. */
1532 find_new_threads_once (struct thread_db_info
*info
, int iteration
,
1535 struct callback_data data
;
1536 td_err_e err
= TD_ERR
;
1539 data
.new_threads
= 0;
1541 /* See comment in thread_db_update_thread_list. */
1542 gdb_assert (info
->td_ta_thr_iter_p
!= NULL
);
1546 /* Iterate over all user-space threads to discover new threads. */
1547 err
= info
->td_ta_thr_iter_p (info
->thread_agent
,
1548 find_new_threads_callback
,
1551 TD_THR_LOWEST_PRIORITY
,
1553 TD_THR_ANY_USER_FLAGS
);
1555 catch (const gdb_exception_error
&except
)
1557 if (libthread_db_debug
)
1559 exception_fprintf (gdb_stdlog
, except
,
1560 "Warning: find_new_threads_once: ");
1564 if (libthread_db_debug
)
1566 fprintf_unfiltered (gdb_stdlog
,
1567 _("Found %d new threads in iteration %d.\n"),
1568 data
.new_threads
, iteration
);
1574 return data
.new_threads
;
1577 /* Search for new threads, accessing memory through stopped thread
1578 PTID. If UNTIL_NO_NEW is true, repeat searching until several
1579 searches in a row do not discover any new threads. */
1582 thread_db_find_new_threads_2 (thread_info
*stopped
, bool until_no_new
)
1584 td_err_e err
= TD_OK
;
1585 struct thread_db_info
*info
;
1588 info
= get_thread_db_info (stopped
->inf
->process_target (),
1589 stopped
->ptid
.pid ());
1591 /* Access an lwp we know is stopped. */
1592 info
->proc_handle
.thread
= stopped
;
1596 /* Require 4 successive iterations which do not find any new threads.
1597 The 4 is a heuristic: there is an inherent race here, and I have
1598 seen that 2 iterations in a row are not always sufficient to
1599 "capture" all threads. */
1600 for (i
= 0, loop
= 0; loop
< 4 && err
== TD_OK
; ++i
, ++loop
)
1601 if (find_new_threads_once (info
, i
, &err
) != 0)
1603 /* Found some new threads. Restart the loop from beginning. */
1608 find_new_threads_once (info
, 0, &err
);
1611 error (_("Cannot find new threads: %s"), thread_db_err_str (err
));
1615 thread_db_find_new_threads_1 (thread_info
*stopped
)
1617 thread_db_find_new_threads_2 (stopped
, 0);
1620 /* Implement the to_update_thread_list target method for this
1624 thread_db_target::update_thread_list ()
1626 struct thread_db_info
*info
;
1630 for (inferior
*inf
: all_inferiors ())
1635 info
= get_thread_db_info (inf
->process_target (), inf
->pid
);
1639 thread_info
*thread
= any_live_thread_of_inferior (inf
);
1640 if (thread
== NULL
|| thread
->executing ())
1643 /* It's best to avoid td_ta_thr_iter if possible. That walks
1644 data structures in the inferior's address space that may be
1645 corrupted, or, if the target is running, the list may change
1646 while we walk it. In the latter case, it's possible that a
1647 thread exits just at the exact time that causes GDB to get
1648 stuck in an infinite loop. To avoid pausing all threads
1649 whenever the core wants to refresh the thread list, we
1650 instead use thread_from_lwp immediately when we see an LWP
1651 stop. That uses thread_db entry points that do not walk
1652 libpthread's thread list, so should be safe, as well as more
1654 if (thread
->inf
->has_execution ())
1657 thread_db_find_new_threads_1 (thread
);
1660 /* Give the beneath target a chance to do extra processing. */
1661 this->beneath ()->update_thread_list ();
1665 thread_db_target::pid_to_str (ptid_t ptid
)
1667 thread_info
*thread_info
= find_thread_ptid (current_inferior (), ptid
);
1669 if (thread_info
!= NULL
&& thread_info
->priv
!= NULL
)
1671 thread_db_thread_info
*priv
= get_thread_db_thread_info (thread_info
);
1673 return string_printf ("Thread 0x%lx (LWP %ld)",
1674 (unsigned long) priv
->tid
, ptid
.lwp ());
1677 return beneath ()->pid_to_str (ptid
);
1680 /* Return a string describing the state of the thread specified by
1684 thread_db_target::extra_thread_info (thread_info
*info
)
1686 if (info
->priv
== NULL
)
1689 thread_db_thread_info
*priv
= get_thread_db_thread_info (info
);
1697 /* Return pointer to the thread_info struct which corresponds to
1698 THREAD_HANDLE (having length HANDLE_LEN). */
1701 thread_db_target::thread_handle_to_thread_info (const gdb_byte
*thread_handle
,
1705 thread_t handle_tid
;
1707 /* When debugging a 32-bit target from a 64-bit host, handle_len
1708 will be 4 and sizeof (handle_tid) will be 8. This requires
1709 a different cast than the more straightforward case where
1710 the sizes are the same.
1712 Use "--target_board unix/-m32" from a native x86_64 linux build
1713 to test the 32/64-bit case. */
1714 if (handle_len
== 4 && sizeof (handle_tid
) == 8)
1715 handle_tid
= (thread_t
) * (const uint32_t *) thread_handle
;
1716 else if (handle_len
== sizeof (handle_tid
))
1717 handle_tid
= * (const thread_t
*) thread_handle
;
1719 error (_("Thread handle size mismatch: %d vs %zu (from libthread_db)"),
1720 handle_len
, sizeof (handle_tid
));
1722 for (thread_info
*tp
: inf
->non_exited_threads ())
1724 thread_db_thread_info
*priv
= get_thread_db_thread_info (tp
);
1726 if (priv
!= NULL
&& handle_tid
== priv
->tid
)
1733 /* Return the thread handle associated the thread_info pointer TP. */
1736 thread_db_target::thread_info_to_thread_handle (struct thread_info
*tp
)
1738 thread_db_thread_info
*priv
= get_thread_db_thread_info (tp
);
1741 return gdb::byte_vector ();
1743 int handle_size
= sizeof (priv
->tid
);
1744 gdb::byte_vector
rv (handle_size
);
1746 memcpy (rv
.data (), &priv
->tid
, handle_size
);
1751 /* Get the address of the thread local variable in load module LM which
1752 is stored at OFFSET within the thread local storage for thread PTID. */
1755 thread_db_target::get_thread_local_address (ptid_t ptid
,
1759 struct thread_info
*thread_info
;
1760 process_stratum_target
*beneath
1761 = as_process_stratum_target (this->beneath ());
1762 /* Find the matching thread. */
1763 thread_info
= find_thread_ptid (beneath
, ptid
);
1765 /* We may not have discovered the thread yet. */
1766 if (thread_info
!= NULL
&& thread_info
->priv
== NULL
)
1767 thread_info
= thread_from_lwp (thread_info
, ptid
);
1769 if (thread_info
!= NULL
&& thread_info
->priv
!= NULL
)
1773 thread_db_info
*info
= get_thread_db_info (beneath
, ptid
.pid ());
1774 thread_db_thread_info
*priv
= get_thread_db_thread_info (thread_info
);
1776 /* Finally, get the address of the variable. */
1779 /* glibc doesn't provide the needed interface. */
1780 if (!info
->td_thr_tls_get_addr_p
)
1781 throw_error (TLS_NO_LIBRARY_SUPPORT_ERROR
,
1782 _("No TLS library support"));
1784 /* Note the cast through uintptr_t: this interface only works if
1785 a target address fits in a psaddr_t, which is a host pointer.
1786 So a 32-bit debugger can not access 64-bit TLS through this. */
1787 err
= info
->td_thr_tls_get_addr_p (&priv
->th
,
1788 (psaddr_t
)(uintptr_t) lm
,
1793 /* If glibc doesn't provide the needed interface throw an error
1794 that LM is zero - normally cases it should not be. */
1795 if (!info
->td_thr_tlsbase_p
)
1796 throw_error (TLS_LOAD_MODULE_NOT_FOUND_ERROR
,
1797 _("TLS load module not found"));
1799 /* This code path handles the case of -static -pthread executables:
1800 https://sourceware.org/ml/libc-help/2014-03/msg00024.html
1801 For older GNU libc r_debug.r_map is NULL. For GNU libc after
1802 PR libc/16831 due to GDB PR threads/16954 LOAD_MODULE is also NULL.
1803 The constant number 1 depends on GNU __libc_setup_tls
1804 initialization of l_tls_modid to 1. */
1805 err
= info
->td_thr_tlsbase_p (&priv
->th
, 1, &address
);
1806 address
= (char *) address
+ offset
;
1809 #ifdef THREAD_DB_HAS_TD_NOTALLOC
1810 /* The memory hasn't been allocated, yet. */
1811 if (err
== TD_NOTALLOC
)
1812 /* Now, if libthread_db provided the initialization image's
1813 address, we *could* try to build a non-lvalue value from
1814 the initialization image. */
1815 throw_error (TLS_NOT_ALLOCATED_YET_ERROR
,
1816 _("TLS not allocated yet"));
1819 /* Something else went wrong. */
1821 throw_error (TLS_GENERIC_ERROR
,
1822 (("%s")), thread_db_err_str (err
));
1824 /* Cast assuming host == target. Joy. */
1825 /* Do proper sign extension for the target. */
1826 gdb_assert (current_program_space
->exec_bfd ());
1827 return (bfd_get_sign_extend_vma (current_program_space
->exec_bfd ()) > 0
1828 ? (CORE_ADDR
) (intptr_t) address
1829 : (CORE_ADDR
) (uintptr_t) address
);
1832 return beneath
->get_thread_local_address (ptid
, lm
, offset
);
1835 /* Implement the to_get_ada_task_ptid target method for this target. */
1838 thread_db_target::get_ada_task_ptid (long lwp
, ULONGEST thread
)
1840 /* NPTL uses a 1:1 model, so the LWP id suffices. */
1841 return ptid_t (inferior_ptid
.pid (), lwp
);
1845 thread_db_target::resume (ptid_t ptid
, int step
, enum gdb_signal signo
)
1847 process_stratum_target
*beneath
1848 = as_process_stratum_target (this->beneath ());
1850 thread_db_info
*info
1851 = get_thread_db_info (beneath
, (ptid
== minus_one_ptid
1852 ? inferior_ptid
.pid ()
1855 /* This workaround is only needed for child fork lwps stopped in a
1856 PTRACE_O_TRACEFORK event. When the inferior is resumed, the
1857 workaround can be disabled. */
1859 info
->need_stale_parent_threads_check
= 0;
1861 beneath
->resume (ptid
, step
, signo
);
1864 /* std::sort helper function for info_auto_load_libthread_db, sort the
1865 thread_db_info pointers primarily by their FILENAME and secondarily by their
1866 PID, both in ascending order. */
1869 info_auto_load_libthread_db_compare (const struct thread_db_info
*a
,
1870 const struct thread_db_info
*b
)
1874 retval
= strcmp (a
->filename
, b
->filename
);
1878 return a
->pid
< b
->pid
;
1881 /* Implement 'info auto-load libthread-db'. */
1884 info_auto_load_libthread_db (const char *args
, int from_tty
)
1886 struct ui_out
*uiout
= current_uiout
;
1887 const char *cs
= args
? args
: "";
1888 struct thread_db_info
*info
;
1889 unsigned unique_filenames
;
1890 size_t max_filename_len
, pids_len
;
1893 cs
= skip_spaces (cs
);
1895 error (_("'info auto-load libthread-db' does not accept any parameters"));
1897 std::vector
<struct thread_db_info
*> array
;
1898 for (info
= thread_db_list
; info
; info
= info
->next
)
1899 if (info
->filename
!= NULL
)
1900 array
.push_back (info
);
1902 /* Sort ARRAY by filenames and PIDs. */
1903 std::sort (array
.begin (), array
.end (),
1904 info_auto_load_libthread_db_compare
);
1906 /* Calculate the number of unique filenames (rows) and the maximum string
1907 length of PIDs list for the unique filenames (columns). */
1909 unique_filenames
= 0;
1910 max_filename_len
= 0;
1912 for (i
= 0; i
< array
.size (); i
++)
1914 int pid
= array
[i
]->pid
;
1915 size_t this_pid_len
;
1917 for (this_pid_len
= 0; pid
!= 0; pid
/= 10)
1920 if (i
== 0 || strcmp (array
[i
- 1]->filename
, array
[i
]->filename
) != 0)
1923 max_filename_len
= std::max (max_filename_len
,
1924 strlen (array
[i
]->filename
));
1927 pids_len
-= strlen (", ");
1930 pids_len
+= this_pid_len
+ strlen (", ");
1933 pids_len
-= strlen (", ");
1935 /* Table header shifted right by preceding "libthread-db: " would not match
1937 if (array
.size () > 0 && args
== auto_load_info_scripts_pattern_nl
)
1941 ui_out_emit_table
table_emitter (uiout
, 2, unique_filenames
,
1942 "LinuxThreadDbTable");
1944 uiout
->table_header (max_filename_len
, ui_left
, "filename", "Filename");
1945 uiout
->table_header (pids_len
, ui_left
, "PIDs", "Pids");
1946 uiout
->table_body ();
1948 /* Note I is incremented inside the cycle, not at its end. */
1949 for (i
= 0; i
< array
.size ();)
1951 ui_out_emit_tuple
tuple_emitter (uiout
, NULL
);
1954 uiout
->field_string ("filename", info
->filename
);
1957 while (i
< array
.size () && strcmp (info
->filename
,
1958 array
[i
]->filename
) == 0)
1962 string_appendf (pids
, "%u", array
[i
]->pid
);
1966 uiout
->field_string ("pids", pids
);
1973 uiout
->message (_("No auto-loaded libthread-db.\n"));
1976 /* Implement 'maintenance check libthread-db'. */
1979 maintenance_check_libthread_db (const char *args
, int from_tty
)
1981 int inferior_pid
= inferior_ptid
.pid ();
1982 struct thread_db_info
*info
;
1984 if (inferior_pid
== 0)
1985 error (_("No inferior running"));
1987 info
= get_thread_db_info (current_inferior ()->process_target (),
1990 error (_("No libthread_db loaded"));
1992 check_thread_db (info
, true);
1995 void _initialize_thread_db ();
1997 _initialize_thread_db ()
1999 /* Defer loading of libthread_db.so until inferior is running.
2000 This allows gdb to load correct libthread_db for a given
2001 executable -- there could be multiple versions of glibc,
2002 and until there is a running inferior, we can't tell which
2003 libthread_db is the correct one to load. */
2005 add_setshow_optional_filename_cmd ("libthread-db-search-path",
2007 &libthread_db_search_path
, _("\
2008 Set search path for libthread_db."), _("\
2009 Show the current search path or libthread_db."), _("\
2010 This path is used to search for libthread_db to be loaded into \
2012 Its value is a colon (':') separate list of directories to search.\n\
2013 Setting the search path to an empty list resets it to its default value."),
2014 set_libthread_db_search_path
,
2016 &setlist
, &showlist
);
2018 add_setshow_zuinteger_cmd ("libthread-db", class_maintenance
,
2019 &libthread_db_debug
, _("\
2020 Set libthread-db debugging."), _("\
2021 Show libthread-db debugging."), _("\
2022 When non-zero, libthread-db debugging is enabled."),
2024 show_libthread_db_debug
,
2025 &setdebuglist
, &showdebuglist
);
2027 add_setshow_boolean_cmd ("libthread-db", class_support
,
2028 &auto_load_thread_db
, _("\
2029 Enable or disable auto-loading of inferior specific libthread_db."), _("\
2030 Show whether auto-loading inferior specific libthread_db is enabled."), _("\
2031 If enabled, libthread_db will be searched in 'set libthread-db-search-path'\n\
2032 locations to load libthread_db compatible with the inferior.\n\
2033 Standard system libthread_db still gets loaded even with this option off.\n\
2034 This option has security implications for untrusted inferiors."),
2035 NULL
, show_auto_load_thread_db
,
2036 auto_load_set_cmdlist_get (),
2037 auto_load_show_cmdlist_get ());
2039 add_cmd ("libthread-db", class_info
, info_auto_load_libthread_db
,
2040 _("Print the list of loaded inferior specific libthread_db.\n\
2041 Usage: info auto-load libthread-db"),
2042 auto_load_info_cmdlist_get ());
2044 add_cmd ("libthread-db", class_maintenance
,
2045 maintenance_check_libthread_db
, _("\
2046 Run integrity checks on the current inferior's libthread_db."),
2047 &maintenancechecklist
);
2049 add_setshow_boolean_cmd ("check-libthread-db",
2051 &check_thread_db_on_load
, _("\
2052 Set whether to check libthread_db at load time."), _("\
2053 Show whether to check libthread_db at load time."), _("\
2054 If enabled GDB will run integrity checks on inferior specific libthread_db\n\
2055 as they are loaded."),
2058 &maintenance_set_cmdlist
,
2059 &maintenance_show_cmdlist
);
2061 /* Add ourselves to objfile event chain. */
2062 gdb::observers::new_objfile
.attach (thread_db_new_objfile
, "linux-thread-db");
2064 /* Add ourselves to inferior_created event chain.
2065 This is needed to handle debugging statically linked programs where
2066 the new_objfile observer won't get called for libpthread. */
2067 gdb::observers::inferior_created
.attach (thread_db_inferior_created
,