1 /* libthread_db assisted debugging support, generic parts.
3 Copyright (C) 1999-2022 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 gdb_printf (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 gdb_printf (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 gdb::checked_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
= version_msym
.value_address ();
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 gdb_puts (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 gdb_printf (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 gdb_printf (_("[Thread debugging using libthread_db enabled]\n"));
941 if (!libthread_db_search_path
.empty () || libthread_db_debug
)
945 library
= dladdr_to_soname ((const void *) *info
->td_ta_new_p
);
947 library
= LIBTHREAD_DB_SO
;
949 gdb_printf (_("Using host libthread_db library \"%ps\".\n"),
950 styled_string (file_name_style
.style (), library
));
953 /* The thread library was detected. Activate the thread_db target
955 current_inferior ()->push_target (&the_thread_db_target
);
959 /* Attempt to use LIBRARY as libthread_db. LIBRARY could be absolute,
960 relative, or just LIBTHREAD_DB. */
963 try_thread_db_load (const char *library
, bool check_auto_load_safe
)
966 struct thread_db_info
*info
;
968 if (libthread_db_debug
)
969 gdb_printf (gdb_stdlog
,
970 _("Trying host libthread_db library: %s.\n"),
973 if (check_auto_load_safe
)
975 if (access (library
, R_OK
) != 0)
977 /* Do not print warnings by file_is_auto_load_safe if the library does
978 not exist at this place. */
979 if (libthread_db_debug
)
980 gdb_printf (gdb_stdlog
, _("open failed: %s.\n"),
981 safe_strerror (errno
));
985 auto_load_debug_printf
986 ("Loading libthread-db library \"%s\" from explicit directory.",
989 if (!file_is_auto_load_safe (library
))
993 handle
= dlopen (library
, RTLD_NOW
);
996 if (libthread_db_debug
)
997 gdb_printf (gdb_stdlog
, _("dlopen failed: %s.\n"), dlerror ());
1001 if (libthread_db_debug
&& strchr (library
, '/') == NULL
)
1005 td_init
= dlsym (handle
, "td_init");
1006 if (td_init
!= NULL
)
1008 const char *const libpath
= dladdr_to_soname (td_init
);
1010 if (libpath
!= NULL
)
1011 gdb_printf (gdb_stdlog
, _("Host %s resolved to: %s.\n"),
1016 info
= add_thread_db_info (handle
);
1018 /* Do not save system library name, that one is always trusted. */
1019 if (strchr (library
, '/') != NULL
)
1020 info
->filename
= gdb_realpath (library
).release ();
1024 if (try_thread_db_load_1 (info
))
1027 catch (const gdb_exception_error
&except
)
1029 if (libthread_db_debug
)
1030 exception_fprintf (gdb_stdlog
, except
,
1031 "Warning: While trying to load libthread_db: ");
1034 /* This library "refused" to work on current inferior. */
1035 delete_thread_db_info (current_inferior ()->process_target (),
1036 inferior_ptid
.pid ());
1040 /* Subroutine of try_thread_db_load_from_pdir to simplify it.
1041 Try loading libthread_db in directory(OBJ)/SUBDIR.
1042 SUBDIR may be NULL. It may also be something like "../lib64".
1043 The result is true for success. */
1046 try_thread_db_load_from_pdir_1 (struct objfile
*obj
, const char *subdir
)
1048 const char *obj_name
= objfile_name (obj
);
1050 if (obj_name
[0] != '/')
1052 warning (_("Expected absolute pathname for libpthread in the"
1053 " inferior, but got %ps."),
1054 styled_string (file_name_style
.style (), obj_name
));
1058 std::string path
= obj_name
;
1059 size_t cp
= path
.rfind ('/');
1060 /* This should at minimum hit the first character. */
1061 gdb_assert (cp
!= std::string::npos
);
1062 path
.resize (cp
+ 1);
1064 path
= path
+ subdir
+ "/";
1065 path
+= LIBTHREAD_DB_SO
;
1067 return try_thread_db_load (path
.c_str (), true);
1070 /* Handle $pdir in libthread-db-search-path.
1071 Look for libthread_db in directory(libpthread)/SUBDIR.
1072 SUBDIR may be NULL. It may also be something like "../lib64".
1073 The result is true for success. */
1076 try_thread_db_load_from_pdir (const char *subdir
)
1078 if (!auto_load_thread_db
)
1081 for (objfile
*obj
: current_program_space
->objfiles ())
1082 if (libpthread_objfile_p (obj
))
1084 if (try_thread_db_load_from_pdir_1 (obj
, subdir
))
1087 /* We may have found the separate-debug-info version of
1088 libpthread, and it may live in a directory without a matching
1090 if (obj
->separate_debug_objfile_backlink
!= NULL
)
1091 return try_thread_db_load_from_pdir_1 (obj
->separate_debug_objfile_backlink
,
1100 /* Handle $sdir in libthread-db-search-path.
1101 Look for libthread_db in the system dirs, or wherever a plain
1102 dlopen(file_without_path) will look.
1103 The result is true for success. */
1106 try_thread_db_load_from_sdir (void)
1108 return try_thread_db_load (LIBTHREAD_DB_SO
, false);
1111 /* Try to load libthread_db from directory DIR of length DIR_LEN.
1112 The result is true for success. */
1115 try_thread_db_load_from_dir (const char *dir
, size_t dir_len
)
1117 if (!auto_load_thread_db
)
1120 std::string path
= std::string (dir
, dir_len
) + "/" + LIBTHREAD_DB_SO
;
1122 return try_thread_db_load (path
.c_str (), true);
1125 /* Search libthread_db_search_path for libthread_db which "agrees"
1126 to work on current inferior.
1127 The result is true for success. */
1130 thread_db_load_search (void)
1134 std::vector
<gdb::unique_xmalloc_ptr
<char>> dir_vec
1135 = dirnames_to_char_ptr_vec (libthread_db_search_path
.c_str ());
1137 for (const gdb::unique_xmalloc_ptr
<char> &this_dir_up
: dir_vec
)
1139 const char *this_dir
= this_dir_up
.get ();
1140 const int pdir_len
= sizeof ("$pdir") - 1;
1141 size_t this_dir_len
;
1143 this_dir_len
= strlen (this_dir
);
1145 if (strncmp (this_dir
, "$pdir", pdir_len
) == 0
1146 && (this_dir
[pdir_len
] == '\0'
1147 || this_dir
[pdir_len
] == '/'))
1149 const char *subdir
= NULL
;
1151 std::string subdir_holder
;
1152 if (this_dir
[pdir_len
] == '/')
1154 subdir_holder
= std::string (this_dir
+ pdir_len
+ 1);
1155 subdir
= subdir_holder
.c_str ();
1157 rc
= try_thread_db_load_from_pdir (subdir
);
1161 else if (strcmp (this_dir
, "$sdir") == 0)
1163 if (try_thread_db_load_from_sdir ())
1171 if (try_thread_db_load_from_dir (this_dir
, this_dir_len
))
1179 if (libthread_db_debug
)
1180 gdb_printf (gdb_stdlog
,
1181 _("thread_db_load_search returning %d\n"), rc
);
1185 /* Return true if the inferior has a libpthread. */
1188 has_libpthread (void)
1190 for (objfile
*obj
: current_program_space
->objfiles ())
1191 if (libpthread_objfile_p (obj
))
1197 /* Attempt to load and initialize libthread_db.
1198 Return 1 on success. */
1201 thread_db_load (void)
1203 inferior
*inf
= current_inferior ();
1205 /* When attaching / handling fork child, don't try loading libthread_db
1206 until we know about all shared libraries. */
1207 if (inf
->in_initial_library_scan
)
1210 thread_db_info
*info
= get_thread_db_info (inf
->process_target (),
1211 inferior_ptid
.pid ());
1216 /* Don't attempt to use thread_db on executables not running
1218 if (!target_has_registers ())
1221 /* Don't attempt to use thread_db for remote targets. */
1222 if (!(target_can_run () || core_bfd
))
1225 if (thread_db_load_search ())
1228 /* We couldn't find a libthread_db.
1229 If the inferior has a libpthread warn the user. */
1230 if (has_libpthread ())
1232 warning (_("Unable to find libthread_db matching inferior's thread"
1233 " library, thread debugging will not be available."));
1237 /* Either this executable isn't using libpthread at all, or it is
1238 statically linked. Since we can't easily distinguish these two cases,
1239 no warning is issued. */
1244 check_thread_signals (void)
1246 if (!thread_signals
)
1250 for (i
= 0; i
< lin_thread_get_thread_signal_num (); i
++)
1252 int sig
= lin_thread_get_thread_signal (i
);
1253 signal_stop_update (gdb_signal_from_host (sig
), 0);
1254 signal_print_update (gdb_signal_from_host (sig
), 0);
1260 /* Check whether thread_db is usable. This function is called when
1261 an inferior is created (or otherwise acquired, e.g. attached to)
1262 and when new shared libraries are loaded into a running process. */
1265 check_for_thread_db (void)
1267 /* Do nothing if we couldn't load libthread_db.so.1. */
1268 if (!thread_db_load ())
1272 /* This function is called via the new_objfile observer. */
1275 thread_db_new_objfile (struct objfile
*objfile
)
1277 /* This observer must always be called with inferior_ptid set
1281 /* libpthread with separate debug info has its debug info file already
1282 loaded (and notified without successful thread_db initialization)
1283 the time gdb::observers::new_objfile.notify is called for the library itself.
1284 Static executables have their separate debug info loaded already
1285 before the inferior has started. */
1286 && objfile
->separate_debug_objfile_backlink
== NULL
1287 /* Only check for thread_db if we loaded libpthread,
1288 or if this is the main symbol file.
1289 We need to check OBJF_MAINLINE to handle the case of debugging
1290 a statically linked executable AND the symbol file is specified AFTER
1291 the exec file is loaded (e.g., gdb -c core ; file foo).
1292 For dynamically linked executables, libpthread can be near the end
1293 of the list of shared libraries to load, and in an app of several
1294 thousand shared libraries, this can otherwise be painful. */
1295 && ((objfile
->flags
& OBJF_MAINLINE
) != 0
1296 || libpthread_objfile_p (objfile
)))
1297 check_for_thread_db ();
1301 check_pid_namespace_match (inferior
*inf
)
1303 /* Check is only relevant for local targets targets. */
1304 if (target_can_run ())
1306 /* If the child is in a different PID namespace, its idea of its
1307 PID will differ from our idea of its PID. When we scan the
1308 child's thread list, we'll mistakenly think it has no threads
1309 since the thread PID fields won't match the PID we give to
1311 if (!linux_ns_same (inf
->pid
, LINUX_NS_PID
))
1313 warning (_ ("Target and debugger are in different PID "
1314 "namespaces; thread lists and other data are "
1315 "likely unreliable. "
1316 "Connect to gdbserver inside the container."));
1321 /* This function is called via the inferior_created observer.
1322 This handles the case of debugging statically linked executables. */
1325 thread_db_inferior_created (inferior
*inf
)
1327 check_pid_namespace_match (inf
);
1328 check_for_thread_db ();
1331 /* Update the thread's state (what's displayed in "info threads"),
1332 from libthread_db thread state information. */
1335 update_thread_state (thread_db_thread_info
*priv
,
1336 const td_thrinfo_t
*ti_p
)
1338 priv
->dying
= (ti_p
->ti_state
== TD_THR_UNKNOWN
1339 || ti_p
->ti_state
== TD_THR_ZOMBIE
);
1342 /* Record a new thread in GDB's thread list. Creates the thread's
1343 private info. If TP is NULL or TP is marked as having exited,
1344 creates a new thread. Otherwise, uses TP. */
1346 static struct thread_info
*
1347 record_thread (struct thread_db_info
*info
,
1348 struct thread_info
*tp
,
1349 ptid_t ptid
, const td_thrhandle_t
*th_p
,
1350 const td_thrinfo_t
*ti_p
)
1352 /* A thread ID of zero may mean the thread library has not
1353 initialized yet. Leave private == NULL until the thread library
1355 if (ti_p
->ti_tid
== 0)
1358 /* Construct the thread's private data. */
1359 thread_db_thread_info
*priv
= new thread_db_thread_info
;
1362 priv
->tid
= ti_p
->ti_tid
;
1363 update_thread_state (priv
, ti_p
);
1365 /* Add the thread to GDB's thread list. If we already know about a
1366 thread with this PTID, but it's marked exited, then the kernel
1367 reused the tid of an old thread. */
1368 if (tp
== NULL
|| tp
->state
== THREAD_EXITED
)
1369 tp
= add_thread_with_info (info
->process_target
, ptid
, priv
);
1371 tp
->priv
.reset (priv
);
1373 if (target_has_execution ())
1374 check_thread_signals ();
1380 thread_db_target::detach (inferior
*inf
, int from_tty
)
1382 delete_thread_db_info (inf
->process_target (), inf
->pid
);
1384 beneath ()->detach (inf
, from_tty
);
1386 /* NOTE: From this point on, inferior_ptid is null_ptid. */
1388 /* Detach the thread_db target from this inferior. */
1389 inf
->unpush_target (this);
1393 thread_db_target::wait (ptid_t ptid
, struct target_waitstatus
*ourstatus
,
1394 target_wait_flags options
)
1396 struct thread_db_info
*info
;
1398 process_stratum_target
*beneath
1399 = as_process_stratum_target (this->beneath ());
1401 ptid
= beneath
->wait (ptid
, ourstatus
, options
);
1403 switch (ourstatus
->kind ())
1405 case TARGET_WAITKIND_IGNORE
:
1406 case TARGET_WAITKIND_EXITED
:
1407 case TARGET_WAITKIND_THREAD_EXITED
:
1408 case TARGET_WAITKIND_SIGNALLED
:
1409 case TARGET_WAITKIND_EXECD
:
1413 info
= get_thread_db_info (beneath
, ptid
.pid ());
1415 /* If this process isn't using thread_db, we're done. */
1419 /* Fill in the thread's user-level thread id and status. */
1420 thread_from_lwp (find_thread_ptid (beneath
, ptid
), ptid
);
1426 thread_db_target::mourn_inferior ()
1428 process_stratum_target
*target_beneath
1429 = as_process_stratum_target (this->beneath ());
1431 delete_thread_db_info (target_beneath
, inferior_ptid
.pid ());
1433 target_beneath
->mourn_inferior ();
1435 /* Detach the thread_db target from this inferior. */
1436 current_inferior ()->unpush_target (this);
1440 thread_db_target::follow_exec (inferior
*follow_inf
, ptid_t ptid
,
1441 const char *execd_pathname
)
1443 process_stratum_target
*beneath
1444 = as_process_stratum_target (this->beneath ());
1446 delete_thread_db_info (beneath
, ptid
.pid ());
1448 current_inferior ()->unpush_target (this);
1449 beneath
->follow_exec (follow_inf
, ptid
, execd_pathname
);
1452 struct callback_data
1454 struct thread_db_info
*info
;
1459 find_new_threads_callback (const td_thrhandle_t
*th_p
, void *data
)
1463 struct thread_info
*tp
;
1464 struct callback_data
*cb_data
= (struct callback_data
*) data
;
1465 struct thread_db_info
*info
= cb_data
->info
;
1467 err
= info
->td_thr_get_info_p (th_p
, &ti
);
1469 error (_("find_new_threads_callback: cannot get thread info: %s"),
1470 thread_db_err_str (err
));
1472 if (ti
.ti_lid
== -1)
1474 /* A thread with kernel thread ID -1 is either a thread that
1475 exited and was joined, or a thread that is being created but
1476 hasn't started yet, and that is reusing the tcb/stack of a
1477 thread that previously exited and was joined. (glibc marks
1478 terminated and joined threads with kernel thread ID -1. See
1480 if (libthread_db_debug
)
1481 gdb_printf (gdb_stdlog
,
1482 "thread_db: skipping exited and "
1483 "joined thread (0x%lx)\n",
1484 (unsigned long) ti
.ti_tid
);
1490 /* A thread ID of zero means that this is the main thread, but
1491 glibc has not yet initialized thread-local storage and the
1492 pthread library. We do not know what the thread's TID will
1495 /* In that case, we're not stopped in a fork syscall and don't
1496 need this glibc bug workaround. */
1497 info
->need_stale_parent_threads_check
= 0;
1502 /* Ignore stale parent threads, caused by glibc/BZ5983. This is a
1503 bit expensive, as it needs to open /proc/pid/status, so try to
1504 avoid doing the work if we know we don't have to. */
1505 if (info
->need_stale_parent_threads_check
)
1507 int tgid
= linux_proc_get_tgid (ti
.ti_lid
);
1509 if (tgid
!= -1 && tgid
!= info
->pid
)
1513 ptid_t
ptid (info
->pid
, ti
.ti_lid
);
1514 tp
= find_thread_ptid (info
->process_target
, ptid
);
1515 if (tp
== NULL
|| tp
->priv
== NULL
)
1516 record_thread (info
, tp
, ptid
, th_p
, &ti
);
1521 /* Helper for thread_db_find_new_threads_2.
1522 Returns number of new threads found. */
1525 find_new_threads_once (struct thread_db_info
*info
, int iteration
,
1528 struct callback_data data
;
1529 td_err_e err
= TD_ERR
;
1532 data
.new_threads
= 0;
1534 /* See comment in thread_db_update_thread_list. */
1535 gdb_assert (info
->td_ta_thr_iter_p
!= NULL
);
1539 /* Iterate over all user-space threads to discover new threads. */
1540 err
= info
->td_ta_thr_iter_p (info
->thread_agent
,
1541 find_new_threads_callback
,
1544 TD_THR_LOWEST_PRIORITY
,
1546 TD_THR_ANY_USER_FLAGS
);
1548 catch (const gdb_exception_error
&except
)
1550 if (libthread_db_debug
)
1552 exception_fprintf (gdb_stdlog
, except
,
1553 "Warning: find_new_threads_once: ");
1557 if (libthread_db_debug
)
1559 gdb_printf (gdb_stdlog
,
1560 _("Found %d new threads in iteration %d.\n"),
1561 data
.new_threads
, iteration
);
1567 return data
.new_threads
;
1570 /* Search for new threads, accessing memory through stopped thread
1571 PTID. If UNTIL_NO_NEW is true, repeat searching until several
1572 searches in a row do not discover any new threads. */
1575 thread_db_find_new_threads_2 (thread_info
*stopped
, bool until_no_new
)
1577 td_err_e err
= TD_OK
;
1578 struct thread_db_info
*info
;
1581 info
= get_thread_db_info (stopped
->inf
->process_target (),
1582 stopped
->ptid
.pid ());
1584 /* Access an lwp we know is stopped. */
1585 info
->proc_handle
.thread
= stopped
;
1589 /* Require 4 successive iterations which do not find any new threads.
1590 The 4 is a heuristic: there is an inherent race here, and I have
1591 seen that 2 iterations in a row are not always sufficient to
1592 "capture" all threads. */
1593 for (i
= 0, loop
= 0; loop
< 4 && err
== TD_OK
; ++i
, ++loop
)
1594 if (find_new_threads_once (info
, i
, &err
) != 0)
1596 /* Found some new threads. Restart the loop from beginning. */
1601 find_new_threads_once (info
, 0, &err
);
1604 error (_("Cannot find new threads: %s"), thread_db_err_str (err
));
1608 thread_db_find_new_threads_1 (thread_info
*stopped
)
1610 thread_db_find_new_threads_2 (stopped
, 0);
1613 /* Implement the to_update_thread_list target method for this
1617 thread_db_target::update_thread_list ()
1619 struct thread_db_info
*info
;
1621 for (inferior
*inf
: all_inferiors ())
1626 info
= get_thread_db_info (inf
->process_target (), inf
->pid
);
1630 thread_info
*thread
= any_live_thread_of_inferior (inf
);
1631 if (thread
== NULL
|| thread
->executing ())
1634 /* It's best to avoid td_ta_thr_iter if possible. That walks
1635 data structures in the inferior's address space that may be
1636 corrupted, or, if the target is running, the list may change
1637 while we walk it. In the latter case, it's possible that a
1638 thread exits just at the exact time that causes GDB to get
1639 stuck in an infinite loop. To avoid pausing all threads
1640 whenever the core wants to refresh the thread list, we
1641 instead use thread_from_lwp immediately when we see an LWP
1642 stop. That uses thread_db entry points that do not walk
1643 libpthread's thread list, so should be safe, as well as more
1645 if (thread
->inf
->has_execution ())
1648 thread_db_find_new_threads_1 (thread
);
1651 /* Give the beneath target a chance to do extra processing. */
1652 this->beneath ()->update_thread_list ();
1656 thread_db_target::pid_to_str (ptid_t ptid
)
1658 thread_info
*thread_info
= find_thread_ptid (current_inferior (), ptid
);
1660 if (thread_info
!= NULL
&& thread_info
->priv
!= NULL
)
1662 thread_db_thread_info
*priv
= get_thread_db_thread_info (thread_info
);
1664 return string_printf ("Thread 0x%lx (LWP %ld)",
1665 (unsigned long) priv
->tid
, ptid
.lwp ());
1668 return beneath ()->pid_to_str (ptid
);
1671 /* Return a string describing the state of the thread specified by
1675 thread_db_target::extra_thread_info (thread_info
*info
)
1677 if (info
->priv
== NULL
)
1680 thread_db_thread_info
*priv
= get_thread_db_thread_info (info
);
1688 /* Return pointer to the thread_info struct which corresponds to
1689 THREAD_HANDLE (having length HANDLE_LEN). */
1692 thread_db_target::thread_handle_to_thread_info (const gdb_byte
*thread_handle
,
1696 thread_t handle_tid
;
1698 /* When debugging a 32-bit target from a 64-bit host, handle_len
1699 will be 4 and sizeof (handle_tid) will be 8. This requires
1700 a different cast than the more straightforward case where
1701 the sizes are the same.
1703 Use "--target_board unix/-m32" from a native x86_64 linux build
1704 to test the 32/64-bit case. */
1705 if (handle_len
== 4 && sizeof (handle_tid
) == 8)
1706 handle_tid
= (thread_t
) * (const uint32_t *) thread_handle
;
1707 else if (handle_len
== sizeof (handle_tid
))
1708 handle_tid
= * (const thread_t
*) thread_handle
;
1710 error (_("Thread handle size mismatch: %d vs %zu (from libthread_db)"),
1711 handle_len
, sizeof (handle_tid
));
1713 for (thread_info
*tp
: inf
->non_exited_threads ())
1715 thread_db_thread_info
*priv
= get_thread_db_thread_info (tp
);
1717 if (priv
!= NULL
&& handle_tid
== priv
->tid
)
1724 /* Return the thread handle associated the thread_info pointer TP. */
1727 thread_db_target::thread_info_to_thread_handle (struct thread_info
*tp
)
1729 thread_db_thread_info
*priv
= get_thread_db_thread_info (tp
);
1732 return gdb::byte_vector ();
1734 int handle_size
= sizeof (priv
->tid
);
1735 gdb::byte_vector
rv (handle_size
);
1737 memcpy (rv
.data (), &priv
->tid
, handle_size
);
1742 /* Get the address of the thread local variable in load module LM which
1743 is stored at OFFSET within the thread local storage for thread PTID. */
1746 thread_db_target::get_thread_local_address (ptid_t ptid
,
1750 struct thread_info
*thread_info
;
1751 process_stratum_target
*beneath
1752 = as_process_stratum_target (this->beneath ());
1753 /* Find the matching thread. */
1754 thread_info
= find_thread_ptid (beneath
, ptid
);
1756 /* We may not have discovered the thread yet. */
1757 if (thread_info
!= NULL
&& thread_info
->priv
== NULL
)
1758 thread_info
= thread_from_lwp (thread_info
, ptid
);
1760 if (thread_info
!= NULL
&& thread_info
->priv
!= NULL
)
1764 thread_db_info
*info
= get_thread_db_info (beneath
, ptid
.pid ());
1765 thread_db_thread_info
*priv
= get_thread_db_thread_info (thread_info
);
1767 /* Finally, get the address of the variable. */
1770 /* glibc doesn't provide the needed interface. */
1771 if (!info
->td_thr_tls_get_addr_p
)
1772 throw_error (TLS_NO_LIBRARY_SUPPORT_ERROR
,
1773 _("No TLS library support"));
1775 /* Note the cast through uintptr_t: this interface only works if
1776 a target address fits in a psaddr_t, which is a host pointer.
1777 So a 32-bit debugger can not access 64-bit TLS through this. */
1778 err
= info
->td_thr_tls_get_addr_p (&priv
->th
,
1779 (psaddr_t
)(uintptr_t) lm
,
1784 /* If glibc doesn't provide the needed interface throw an error
1785 that LM is zero - normally cases it should not be. */
1786 if (!info
->td_thr_tlsbase_p
)
1787 throw_error (TLS_LOAD_MODULE_NOT_FOUND_ERROR
,
1788 _("TLS load module not found"));
1790 /* This code path handles the case of -static -pthread executables:
1791 https://sourceware.org/ml/libc-help/2014-03/msg00024.html
1792 For older GNU libc r_debug.r_map is NULL. For GNU libc after
1793 PR libc/16831 due to GDB PR threads/16954 LOAD_MODULE is also NULL.
1794 The constant number 1 depends on GNU __libc_setup_tls
1795 initialization of l_tls_modid to 1. */
1796 err
= info
->td_thr_tlsbase_p (&priv
->th
, 1, &address
);
1797 address
= (char *) address
+ offset
;
1800 #ifdef THREAD_DB_HAS_TD_NOTALLOC
1801 /* The memory hasn't been allocated, yet. */
1802 if (err
== TD_NOTALLOC
)
1803 /* Now, if libthread_db provided the initialization image's
1804 address, we *could* try to build a non-lvalue value from
1805 the initialization image. */
1806 throw_error (TLS_NOT_ALLOCATED_YET_ERROR
,
1807 _("TLS not allocated yet"));
1810 /* Something else went wrong. */
1812 throw_error (TLS_GENERIC_ERROR
,
1813 (("%s")), thread_db_err_str (err
));
1815 /* Cast assuming host == target. Joy. */
1816 /* Do proper sign extension for the target. */
1817 gdb_assert (current_program_space
->exec_bfd ());
1818 return (bfd_get_sign_extend_vma (current_program_space
->exec_bfd ()) > 0
1819 ? (CORE_ADDR
) (intptr_t) address
1820 : (CORE_ADDR
) (uintptr_t) address
);
1823 return beneath
->get_thread_local_address (ptid
, lm
, offset
);
1826 /* Implement the to_get_ada_task_ptid target method for this target. */
1829 thread_db_target::get_ada_task_ptid (long lwp
, ULONGEST thread
)
1831 /* NPTL uses a 1:1 model, so the LWP id suffices. */
1832 return ptid_t (inferior_ptid
.pid (), lwp
);
1836 thread_db_target::resume (ptid_t ptid
, int step
, enum gdb_signal signo
)
1838 process_stratum_target
*beneath
1839 = as_process_stratum_target (this->beneath ());
1841 thread_db_info
*info
1842 = get_thread_db_info (beneath
, (ptid
== minus_one_ptid
1843 ? inferior_ptid
.pid ()
1846 /* This workaround is only needed for child fork lwps stopped in a
1847 PTRACE_O_TRACEFORK event. When the inferior is resumed, the
1848 workaround can be disabled. */
1850 info
->need_stale_parent_threads_check
= 0;
1852 beneath
->resume (ptid
, step
, signo
);
1855 /* std::sort helper function for info_auto_load_libthread_db, sort the
1856 thread_db_info pointers primarily by their FILENAME and secondarily by their
1857 PID, both in ascending order. */
1860 info_auto_load_libthread_db_compare (const struct thread_db_info
*a
,
1861 const struct thread_db_info
*b
)
1865 retval
= strcmp (a
->filename
, b
->filename
);
1869 return a
->pid
< b
->pid
;
1872 /* Implement 'info auto-load libthread-db'. */
1875 info_auto_load_libthread_db (const char *args
, int from_tty
)
1877 struct ui_out
*uiout
= current_uiout
;
1878 const char *cs
= args
? args
: "";
1879 struct thread_db_info
*info
;
1880 unsigned unique_filenames
;
1881 size_t max_filename_len
, pids_len
;
1884 cs
= skip_spaces (cs
);
1886 error (_("'info auto-load libthread-db' does not accept any parameters"));
1888 std::vector
<struct thread_db_info
*> array
;
1889 for (info
= thread_db_list
; info
; info
= info
->next
)
1890 if (info
->filename
!= NULL
)
1891 array
.push_back (info
);
1893 /* Sort ARRAY by filenames and PIDs. */
1894 std::sort (array
.begin (), array
.end (),
1895 info_auto_load_libthread_db_compare
);
1897 /* Calculate the number of unique filenames (rows) and the maximum string
1898 length of PIDs list for the unique filenames (columns). */
1900 unique_filenames
= 0;
1901 max_filename_len
= 0;
1903 for (i
= 0; i
< array
.size (); i
++)
1905 int pid
= array
[i
]->pid
;
1906 size_t this_pid_len
;
1908 for (this_pid_len
= 0; pid
!= 0; pid
/= 10)
1911 if (i
== 0 || strcmp (array
[i
- 1]->filename
, array
[i
]->filename
) != 0)
1914 max_filename_len
= std::max (max_filename_len
,
1915 strlen (array
[i
]->filename
));
1918 pids_len
-= strlen (", ");
1921 pids_len
+= this_pid_len
+ strlen (", ");
1924 pids_len
-= strlen (", ");
1926 /* Table header shifted right by preceding "libthread-db: " would not match
1928 if (array
.size () > 0 && args
== auto_load_info_scripts_pattern_nl
)
1932 ui_out_emit_table
table_emitter (uiout
, 2, unique_filenames
,
1933 "LinuxThreadDbTable");
1935 uiout
->table_header (max_filename_len
, ui_left
, "filename", "Filename");
1936 uiout
->table_header (pids_len
, ui_left
, "PIDs", "Pids");
1937 uiout
->table_body ();
1939 /* Note I is incremented inside the cycle, not at its end. */
1940 for (i
= 0; i
< array
.size ();)
1942 ui_out_emit_tuple
tuple_emitter (uiout
, NULL
);
1945 uiout
->field_string ("filename", info
->filename
,
1946 file_name_style
.style ());
1949 while (i
< array
.size () && strcmp (info
->filename
,
1950 array
[i
]->filename
) == 0)
1954 string_appendf (pids
, "%u", array
[i
]->pid
);
1958 uiout
->field_string ("pids", pids
);
1965 uiout
->message (_("No auto-loaded libthread-db.\n"));
1968 /* Implement 'maintenance check libthread-db'. */
1971 maintenance_check_libthread_db (const char *args
, int from_tty
)
1973 int inferior_pid
= inferior_ptid
.pid ();
1974 struct thread_db_info
*info
;
1976 if (inferior_pid
== 0)
1977 error (_("No inferior running"));
1979 info
= get_thread_db_info (current_inferior ()->process_target (),
1982 error (_("No libthread_db loaded"));
1984 check_thread_db (info
, true);
1987 void _initialize_thread_db ();
1989 _initialize_thread_db ()
1991 /* Defer loading of libthread_db.so until inferior is running.
1992 This allows gdb to load correct libthread_db for a given
1993 executable -- there could be multiple versions of glibc,
1994 and until there is a running inferior, we can't tell which
1995 libthread_db is the correct one to load. */
1997 add_setshow_optional_filename_cmd ("libthread-db-search-path",
1999 &libthread_db_search_path
, _("\
2000 Set search path for libthread_db."), _("\
2001 Show the current search path or libthread_db."), _("\
2002 This path is used to search for libthread_db to be loaded into \
2004 Its value is a colon (':') separate list of directories to search.\n\
2005 Setting the search path to an empty list resets it to its default value."),
2006 set_libthread_db_search_path
,
2008 &setlist
, &showlist
);
2010 add_setshow_zuinteger_cmd ("libthread-db", class_maintenance
,
2011 &libthread_db_debug
, _("\
2012 Set libthread-db debugging."), _("\
2013 Show libthread-db debugging."), _("\
2014 When non-zero, libthread-db debugging is enabled."),
2016 show_libthread_db_debug
,
2017 &setdebuglist
, &showdebuglist
);
2019 add_setshow_boolean_cmd ("libthread-db", class_support
,
2020 &auto_load_thread_db
, _("\
2021 Enable or disable auto-loading of inferior specific libthread_db."), _("\
2022 Show whether auto-loading inferior specific libthread_db is enabled."), _("\
2023 If enabled, libthread_db will be searched in 'set libthread-db-search-path'\n\
2024 locations to load libthread_db compatible with the inferior.\n\
2025 Standard system libthread_db still gets loaded even with this option off.\n\
2026 This option has security implications for untrusted inferiors."),
2027 NULL
, show_auto_load_thread_db
,
2028 auto_load_set_cmdlist_get (),
2029 auto_load_show_cmdlist_get ());
2031 add_cmd ("libthread-db", class_info
, info_auto_load_libthread_db
,
2032 _("Print the list of loaded inferior specific libthread_db.\n\
2033 Usage: info auto-load libthread-db"),
2034 auto_load_info_cmdlist_get ());
2036 add_cmd ("libthread-db", class_maintenance
,
2037 maintenance_check_libthread_db
, _("\
2038 Run integrity checks on the current inferior's libthread_db."),
2039 &maintenancechecklist
);
2041 add_setshow_boolean_cmd ("check-libthread-db",
2043 &check_thread_db_on_load
, _("\
2044 Set whether to check libthread_db at load time."), _("\
2045 Show whether to check libthread_db at load time."), _("\
2046 If enabled GDB will run integrity checks on inferior specific libthread_db\n\
2047 as they are loaded."),
2050 &maintenance_set_cmdlist
,
2051 &maintenance_show_cmdlist
);
2053 /* Add ourselves to objfile event chain. */
2054 gdb::observers::new_objfile
.attach (thread_db_new_objfile
, "linux-thread-db");
2056 /* Add ourselves to inferior_created event chain.
2057 This is needed to handle debugging statically linked programs where
2058 the new_objfile observer won't get called for libpthread. */
2059 gdb::observers::inferior_created
.attach (thread_db_inferior_created
,