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 update_thread_list () override
;
99 std::string
pid_to_str (ptid_t
) override
;
100 CORE_ADDR
get_thread_local_address (ptid_t ptid
,
101 CORE_ADDR load_module_addr
,
102 CORE_ADDR offset
) override
;
103 const char *extra_thread_info (struct thread_info
*) override
;
104 ptid_t
get_ada_task_ptid (long lwp
, long thread
) override
;
106 thread_info
*thread_handle_to_thread_info (const gdb_byte
*thread_handle
,
108 inferior
*inf
) override
;
109 gdb::byte_vector
thread_info_to_thread_handle (struct thread_info
*) override
;
112 static char *libthread_db_search_path
;
114 /* Set to true if thread_db auto-loading is enabled
115 by the "set auto-load libthread-db" command. */
116 static bool auto_load_thread_db
= true;
118 /* Set to true if load-time libthread_db tests have been enabled
119 by the "maintenance set check-libthread-db" command. */
120 static bool check_thread_db_on_load
= false;
122 /* "show" command for the auto_load_thread_db configuration variable. */
125 show_auto_load_thread_db (struct ui_file
*file
, int from_tty
,
126 struct cmd_list_element
*c
, const char *value
)
128 fprintf_filtered (file
, _("Auto-loading of inferior specific libthread_db "
134 set_libthread_db_search_path (const char *ignored
, int from_tty
,
135 struct cmd_list_element
*c
)
137 if (*libthread_db_search_path
== '\0')
139 xfree (libthread_db_search_path
);
140 libthread_db_search_path
= xstrdup (LIBTHREAD_DB_SEARCH_PATH
);
144 /* If non-zero, print details of libthread_db processing. */
146 static unsigned int libthread_db_debug
;
149 show_libthread_db_debug (struct ui_file
*file
, int from_tty
,
150 struct cmd_list_element
*c
, const char *value
)
152 fprintf_filtered (file
, _("libthread-db debugging is %s.\n"), value
);
155 /* If we're running on GNU/Linux, we must explicitly attach to any new
158 /* This module's target vector. */
159 static thread_db_target the_thread_db_target
;
161 /* Non-zero if we have determined the signals used by the threads
163 static int thread_signals
;
164 static sigset_t thread_stop_set
;
165 static sigset_t thread_print_set
;
167 struct thread_db_info
169 struct thread_db_info
*next
;
171 /* The target this thread_db_info is bound to. */
172 process_stratum_target
*process_target
;
174 /* Process id this object refers to. */
177 /* Handle from dlopen for libthread_db.so. */
180 /* Absolute pathname from gdb_realpath to disk file used for dlopen-ing
181 HANDLE. It may be NULL for system library. */
184 /* Structure that identifies the child process for the
185 <proc_service.h> interface. */
186 struct ps_prochandle proc_handle
;
188 /* Connection to the libthread_db library. */
189 td_thragent_t
*thread_agent
;
191 /* True if we need to apply the workaround for glibc/BZ5983. When
192 we catch a PTRACE_O_TRACEFORK, and go query the child's thread
193 list, nptl_db returns the parent's threads in addition to the new
194 (single) child thread. If this flag is set, we do extra work to
195 be able to ignore such stale entries. */
196 int need_stale_parent_threads_check
;
198 /* Pointers to the libthread_db functions. */
200 td_init_ftype
*td_init_p
;
201 td_ta_new_ftype
*td_ta_new_p
;
202 td_ta_delete_ftype
*td_ta_delete_p
;
203 td_ta_map_lwp2thr_ftype
*td_ta_map_lwp2thr_p
;
204 td_ta_thr_iter_ftype
*td_ta_thr_iter_p
;
205 td_thr_get_info_ftype
*td_thr_get_info_p
;
206 td_thr_tls_get_addr_ftype
*td_thr_tls_get_addr_p
;
207 td_thr_tlsbase_ftype
*td_thr_tlsbase_p
;
210 /* List of known processes using thread_db, and the required
212 static thread_db_info
*thread_db_list
;
214 static void thread_db_find_new_threads_1 (thread_info
*stopped
);
215 static void thread_db_find_new_threads_2 (thread_info
*stopped
,
218 static void check_thread_signals (void);
220 static struct thread_info
*record_thread
221 (struct thread_db_info
*info
, struct thread_info
*tp
,
222 ptid_t ptid
, const td_thrhandle_t
*th_p
, const td_thrinfo_t
*ti_p
);
224 /* Add the current inferior to the list of processes using libpthread.
225 Return a pointer to the newly allocated object that was added to
226 THREAD_DB_LIST. HANDLE is the handle returned by dlopen'ing
229 static struct thread_db_info
*
230 add_thread_db_info (void *handle
)
232 struct thread_db_info
*info
= XCNEW (struct thread_db_info
);
234 info
->process_target
= current_inferior ()->process_target ();
235 info
->pid
= inferior_ptid
.pid ();
236 info
->handle
= handle
;
238 /* The workaround works by reading from /proc/pid/status, so it is
239 disabled for core files. */
240 if (target_has_execution ())
241 info
->need_stale_parent_threads_check
= 1;
243 info
->next
= thread_db_list
;
244 thread_db_list
= info
;
249 /* Return the thread_db_info object representing the bookkeeping
250 related to process PID, if any; NULL otherwise. */
252 static struct thread_db_info
*
253 get_thread_db_info (process_stratum_target
*targ
, int pid
)
255 struct thread_db_info
*info
;
257 for (info
= thread_db_list
; info
; info
= info
->next
)
258 if (targ
== info
->process_target
&& pid
== info
->pid
)
264 static const char *thread_db_err_str (td_err_e err
);
266 /* When PID has exited or has been detached, we no longer want to keep
267 track of it as using libpthread. Call this function to discard
268 thread_db related info related to PID. Note that this closes
269 LIBTHREAD_DB_SO's dlopen'ed handle. */
272 delete_thread_db_info (process_stratum_target
*targ
, int pid
)
274 struct thread_db_info
*info
, *info_prev
;
278 for (info
= thread_db_list
; info
; info_prev
= info
, info
= info
->next
)
279 if (targ
== info
->process_target
&& pid
== info
->pid
)
285 if (info
->thread_agent
!= NULL
&& info
->td_ta_delete_p
!= NULL
)
287 td_err_e err
= info
->td_ta_delete_p (info
->thread_agent
);
290 warning (_("Cannot deregister process %d from libthread_db: %s"),
291 pid
, thread_db_err_str (err
));
292 info
->thread_agent
= NULL
;
295 if (info
->handle
!= NULL
)
296 dlclose (info
->handle
);
298 xfree (info
->filename
);
301 info_prev
->next
= info
->next
;
303 thread_db_list
= info
->next
;
308 /* Use "struct private_thread_info" to cache thread state. This is
309 a substantial optimization. */
311 struct thread_db_thread_info
: public private_thread_info
313 /* Flag set when we see a TD_DEATH event for this thread. */
316 /* Cached thread state. */
317 td_thrhandle_t th
{};
321 static thread_db_thread_info
*
322 get_thread_db_thread_info (thread_info
*thread
)
324 return static_cast<thread_db_thread_info
*> (thread
->priv
.get ());
328 thread_db_err_str (td_err_e err
)
335 return "generic 'call succeeded'";
337 return "generic error";
339 return "no thread to satisfy query";
341 return "no sync handle to satisfy query";
343 return "no LWP to satisfy query";
345 return "invalid process handle";
347 return "invalid thread handle";
349 return "invalid synchronization handle";
351 return "invalid thread agent";
353 return "invalid key";
355 return "no event message for getmsg";
357 return "FPU register set not available";
359 return "application not linked with libthread";
361 return "requested event is not supported";
363 return "capability not available";
365 return "debugger service failed";
367 return "operation not applicable to";
369 return "no thread-specific data for this thread";
371 return "malloc failed";
373 return "only part of register set was written/read";
375 return "X register set not available for this thread";
376 #ifdef THREAD_DB_HAS_TD_NOTALLOC
378 return "thread has not yet allocated TLS for given module";
380 #ifdef THREAD_DB_HAS_TD_VERSION
382 return "versions of libpthread and libthread_db do not match";
384 #ifdef THREAD_DB_HAS_TD_NOTLS
386 return "there is no TLS segment in the given module";
389 snprintf (buf
, sizeof (buf
), "unknown thread_db error '%d'", err
);
394 /* Fetch the user-level thread id of PTID. STOPPED is a stopped
395 thread that we can use to access memory. */
397 static struct thread_info
*
398 thread_from_lwp (thread_info
*stopped
, ptid_t ptid
)
403 struct thread_db_info
*info
;
404 struct thread_info
*tp
;
406 /* Just in case td_ta_map_lwp2thr doesn't initialize it completely. */
409 /* This ptid comes from linux-nat.c, which should always fill in the
411 gdb_assert (ptid
.lwp () != 0);
413 info
= get_thread_db_info (stopped
->inf
->process_target (), ptid
.pid ());
415 /* Access an lwp we know is stopped. */
416 info
->proc_handle
.thread
= stopped
;
417 err
= info
->td_ta_map_lwp2thr_p (info
->thread_agent
, ptid
.lwp (),
420 error (_("Cannot find user-level thread for LWP %ld: %s"),
421 ptid
.lwp (), thread_db_err_str (err
));
423 err
= info
->td_thr_get_info_p (&th
, &ti
);
425 error (_("thread_get_info_callback: cannot get thread info: %s"),
426 thread_db_err_str (err
));
428 /* Fill the cache. */
429 tp
= find_thread_ptid (stopped
->inf
->process_target (), ptid
);
430 return record_thread (info
, tp
, ptid
, &th
, &ti
);
434 /* See linux-nat.h. */
437 thread_db_notice_clone (ptid_t parent
, ptid_t child
)
439 struct thread_db_info
*info
;
441 info
= get_thread_db_info (linux_target
, child
.pid ());
446 thread_info
*stopped
= find_thread_ptid (linux_target
, parent
);
448 thread_from_lwp (stopped
, child
);
450 /* If we do not know about the main thread's pthread info yet, this
451 would be a good time to find it. */
452 thread_from_lwp (stopped
, parent
);
457 verbose_dlsym (void *handle
, const char *name
)
459 void *sym
= dlsym (handle
, name
);
461 warning (_("Symbol \"%s\" not found in libthread_db: %s"),
466 /* Verify inferior's '\0'-terminated symbol VER_SYMBOL starts with "%d.%d" and
467 return 1 if this version is lower (and not equal) to
468 VER_MAJOR_MIN.VER_MINOR_MIN. Return 0 in all other cases. */
471 inferior_has_bug (const char *ver_symbol
, int ver_major_min
, int ver_minor_min
)
473 struct bound_minimal_symbol version_msym
;
474 CORE_ADDR version_addr
;
477 version_msym
= lookup_minimal_symbol (ver_symbol
, NULL
, NULL
);
478 if (version_msym
.minsym
== NULL
)
481 version_addr
= BMSYMBOL_VALUE_ADDRESS (version_msym
);
482 gdb::unique_xmalloc_ptr
<char> version
483 = target_read_string (version_addr
, 32, &got
);
484 if (version
!= nullptr
485 && memchr (version
.get (), 0, got
) == version
.get () + got
- 1)
489 retval
= (sscanf (version
.get (), "%d.%d", &major
, &minor
) == 2
490 && (major
< ver_major_min
491 || (major
== ver_major_min
&& minor
< ver_minor_min
)));
497 /* Similar as thread_db_find_new_threads_1, but try to silently ignore errors
500 Return 1 if the caller should abort libthread_db initialization. Return 0
504 thread_db_find_new_threads_silently (thread_info
*stopped
)
509 thread_db_find_new_threads_2 (stopped
, true);
512 catch (const gdb_exception_error
&except
)
514 if (libthread_db_debug
)
515 exception_fprintf (gdb_stdlog
, except
,
516 "Warning: thread_db_find_new_threads_silently: ");
518 /* There is a bug fixed between nptl 2.6.1 and 2.7 by
519 commit 7d9d8bd18906fdd17364f372b160d7ab896ce909
520 where calls to td_thr_get_info fail with TD_ERR for statically linked
521 executables if td_thr_get_info is called before glibc has initialized
524 If the nptl bug is NOT present in the inferior and still thread_db
525 reports an error return 1. It means the inferior has corrupted thread
526 list and GDB should fall back only to LWPs.
528 If the nptl bug is present in the inferior return 0 to silently ignore
529 such errors, and let gdb enumerate threads again later. In such case
530 GDB cannot properly display LWPs if the inferior thread list is
531 corrupted. For core files it does not apply, no 'later enumeration'
534 if (!target_has_execution () || !inferior_has_bug ("nptl_version", 2, 7))
536 exception_fprintf (gdb_stderr
, except
,
537 _("Warning: couldn't activate thread debugging "
538 "using libthread_db: "));
546 /* Lookup a library in which given symbol resides.
547 Note: this is looking in GDB process, not in the inferior.
548 Returns library name, or NULL. */
551 dladdr_to_soname (const void *addr
)
555 if (dladdr (addr
, &info
) != 0)
556 return info
.dli_fname
;
560 /* State for check_thread_db_callback. */
562 struct check_thread_db_info
564 /* The libthread_db under test. */
565 struct thread_db_info
*info
;
567 /* True if progress should be logged. */
570 /* True if the callback was called. */
573 /* Name of last libthread_db function called. */
574 const char *last_call
;
576 /* Value returned by last libthread_db call. */
577 td_err_e last_result
;
580 static struct check_thread_db_info
*tdb_testinfo
;
582 /* Callback for check_thread_db. */
585 check_thread_db_callback (const td_thrhandle_t
*th
, void *arg
)
587 gdb_assert (tdb_testinfo
!= NULL
);
588 tdb_testinfo
->threads_seen
= true;
590 #define LOG(fmt, args...) \
593 if (tdb_testinfo->log_progress) \
595 debug_printf (fmt, ## args); \
596 gdb_flush (gdb_stdlog); \
601 #define CHECK_1(expr, args...) \
606 LOG (" ... FAIL!\n"); \
612 #define CHECK(expr) \
613 CHECK_1 (expr, "(%s) == false", #expr)
615 #define CALL_UNCHECKED(func, args...) \
618 tdb_testinfo->last_call = #func; \
619 tdb_testinfo->last_result \
620 = tdb_testinfo->info->func ## _p (args); \
624 #define CHECK_CALL() \
625 CHECK_1 (tdb_testinfo->last_result == TD_OK, \
626 _("%s failed: %s"), \
627 tdb_testinfo->last_call, \
628 thread_db_err_str (tdb_testinfo->last_result)) \
630 #define CALL(func, args...) \
633 CALL_UNCHECKED (func, args); \
640 /* Check td_ta_thr_iter passed consistent arguments. */
642 CHECK (arg
== (void *) tdb_testinfo
);
643 CHECK (th
->th_ta_p
== tdb_testinfo
->info
->thread_agent
);
645 LOG (" %s", core_addr_to_string_nz ((CORE_ADDR
) th
->th_unique
));
647 /* Check td_thr_get_info. */
649 CALL (td_thr_get_info
, th
, &ti
);
651 LOG (" => %d", ti
.ti_lid
);
653 CHECK (ti
.ti_ta_p
== th
->th_ta_p
);
654 CHECK (ti
.ti_tid
== (thread_t
) th
->th_unique
);
656 /* Check td_ta_map_lwp2thr. */
658 memset (&th2
, 23, sizeof (td_thrhandle_t
));
659 CALL_UNCHECKED (td_ta_map_lwp2thr
, th
->th_ta_p
, ti
.ti_lid
, &th2
);
661 if (tdb_testinfo
->last_result
== TD_ERR
&& !target_has_execution ())
663 /* Some platforms require execution for td_ta_map_lwp2thr. */
664 LOG (_("; can't map_lwp2thr"));
670 LOG (" => %s", core_addr_to_string_nz ((CORE_ADDR
) th2
.th_unique
));
672 CHECK (memcmp (th
, &th2
, sizeof (td_thrhandle_t
)) == 0);
675 /* Attempt TLS access. Assuming errno is TLS, this calls
676 thread_db_get_thread_local_address, which in turn calls
677 td_thr_tls_get_addr for live inferiors or td_thr_tlsbase
678 for core files. This test is skipped if the thread has
679 not been recorded; proceeding in that case would result
680 in the test having the side-effect of noticing threads
683 Note that in glibc's libthread_db td_thr_tls_get_addr is
684 a thin wrapper around td_thr_tlsbase; this check always
685 hits the bulk of the code.
687 Note also that we don't actually check any libthread_db
688 calls are made, we just assume they were; future changes
689 to how GDB accesses TLS could result in this passing
690 without exercising the calls it's supposed to. */
691 ptid_t ptid
= ptid_t (tdb_testinfo
->info
->pid
, ti
.ti_lid
, 0);
692 thread_info
*thread_info
= find_thread_ptid (linux_target
, ptid
);
693 if (thread_info
!= NULL
&& thread_info
->priv
!= NULL
)
697 scoped_restore_current_thread restore_current_thread
;
698 switch_to_thread (thread_info
);
700 expression_up expr
= parse_expression ("(int) errno");
701 struct value
*val
= evaluate_expression (expr
.get ());
703 if (tdb_testinfo
->log_progress
)
705 struct value_print_options opts
;
707 get_user_print_options (&opts
);
709 value_print (val
, gdb_stdlog
, &opts
);
718 #undef CALL_UNCHECKED
725 /* Run integrity checks on the dlopen()ed libthread_db described by
726 INFO. Returns true on success, displays a warning and returns
727 false on failure. Logs progress messages to gdb_stdlog during
728 the test if LOG_PROGRESS is true. */
731 check_thread_db (struct thread_db_info
*info
, bool log_progress
)
733 bool test_passed
= true;
736 debug_printf (_("Running libthread_db integrity checks:\n"));
738 /* GDB avoids using td_ta_thr_iter wherever possible (see comment
739 in try_thread_db_load_1 below) so in order to test it we may
740 have to locate it ourselves. */
741 td_ta_thr_iter_ftype
*td_ta_thr_iter_p
= info
->td_ta_thr_iter_p
;
742 if (td_ta_thr_iter_p
== NULL
)
744 void *thr_iter
= verbose_dlsym (info
->handle
, "td_ta_thr_iter");
745 if (thr_iter
== NULL
)
748 td_ta_thr_iter_p
= (td_ta_thr_iter_ftype
*) thr_iter
;
751 /* Set up the test state we share with the callback. */
752 gdb_assert (tdb_testinfo
== NULL
);
753 struct check_thread_db_info tdb_testinfo_buf
;
754 tdb_testinfo
= &tdb_testinfo_buf
;
756 memset (tdb_testinfo
, 0, sizeof (struct check_thread_db_info
));
757 tdb_testinfo
->info
= info
;
758 tdb_testinfo
->log_progress
= log_progress
;
760 /* td_ta_thr_iter shouldn't be used on running processes. Note that
761 it's possible the inferior will stop midway through modifying one
762 of its thread lists, in which case the check will spuriously
764 linux_stop_and_wait_all_lwps ();
768 td_err_e err
= td_ta_thr_iter_p (info
->thread_agent
,
769 check_thread_db_callback
,
772 TD_THR_LOWEST_PRIORITY
,
774 TD_THR_ANY_USER_FLAGS
);
777 error (_("td_ta_thr_iter failed: %s"), thread_db_err_str (err
));
779 if (!tdb_testinfo
->threads_seen
)
780 error (_("no threads seen"));
782 catch (const gdb_exception_error
&except
)
784 if (warning_pre_print
)
785 fputs_unfiltered (warning_pre_print
, gdb_stderr
);
787 exception_fprintf (gdb_stderr
, except
,
788 _("libthread_db integrity checks failed: "));
793 if (test_passed
&& log_progress
)
794 debug_printf (_("libthread_db integrity checks passed.\n"));
798 linux_unstop_all_lwps ();
803 /* Attempt to initialize dlopen()ed libthread_db, described by INFO.
804 Return true on success.
805 Failure could happen if libthread_db does not have symbols we expect,
806 or when it refuses to work with the current inferior (e.g. due to
807 version mismatch between libthread_db and libpthread). */
810 try_thread_db_load_1 (struct thread_db_info
*info
)
814 /* Initialize pointers to the dynamic library functions we will use.
815 Essential functions first. */
817 #define TDB_VERBOSE_DLSYM(info, func) \
818 info->func ## _p = (func ## _ftype *) verbose_dlsym (info->handle, #func)
820 #define TDB_DLSYM(info, func) \
821 info->func ## _p = (func ## _ftype *) dlsym (info->handle, #func)
830 CHK (TDB_VERBOSE_DLSYM (info
, td_init
));
832 err
= info
->td_init_p ();
835 warning (_("Cannot initialize libthread_db: %s"),
836 thread_db_err_str (err
));
840 CHK (TDB_VERBOSE_DLSYM (info
, td_ta_new
));
842 /* Initialize the structure that identifies the child process. */
843 info
->proc_handle
.thread
= inferior_thread ();
845 /* Now attempt to open a connection to the thread library. */
846 err
= info
->td_ta_new_p (&info
->proc_handle
, &info
->thread_agent
);
849 if (libthread_db_debug
)
850 fprintf_unfiltered (gdb_stdlog
, _("td_ta_new failed: %s\n"),
851 thread_db_err_str (err
));
856 #ifdef THREAD_DB_HAS_TD_VERSION
859 /* The errors above are not unexpected and silently ignored:
860 they just mean we haven't found correct version of
864 warning (_("td_ta_new failed: %s"), thread_db_err_str (err
));
869 /* These are essential. */
870 CHK (TDB_VERBOSE_DLSYM (info
, td_ta_map_lwp2thr
));
871 CHK (TDB_VERBOSE_DLSYM (info
, td_thr_get_info
));
873 /* These are not essential. */
874 TDB_DLSYM (info
, td_thr_tls_get_addr
);
875 TDB_DLSYM (info
, td_thr_tlsbase
);
876 TDB_DLSYM (info
, td_ta_delete
);
878 /* It's best to avoid td_ta_thr_iter if possible. That walks data
879 structures in the inferior's address space that may be corrupted,
880 or, if the target is running, may change while we walk them. If
881 there's execution (and /proc is mounted), then we're already
882 attached to all LWPs. Use thread_from_lwp, which uses
883 td_ta_map_lwp2thr instead, which does not walk the thread list.
885 td_ta_map_lwp2thr uses ps_get_thread_area, but we can't use that
886 currently on core targets, as it uses ptrace directly. */
887 if (target_has_execution ()
888 && linux_proc_task_list_dir_exists (inferior_ptid
.pid ()))
889 info
->td_ta_thr_iter_p
= NULL
;
891 CHK (TDB_VERBOSE_DLSYM (info
, td_ta_thr_iter
));
893 #undef TDB_VERBOSE_DLSYM
897 /* Run integrity checks if requested. */
898 if (check_thread_db_on_load
)
900 if (!check_thread_db (info
, libthread_db_debug
))
904 if (info
->td_ta_thr_iter_p
== NULL
)
907 int pid
= inferior_ptid
.pid ();
908 thread_info
*curr_thread
= inferior_thread ();
910 linux_stop_and_wait_all_lwps ();
913 if (lp
->ptid
.pid () == pid
)
914 thread_from_lwp (curr_thread
, lp
->ptid
);
916 linux_unstop_all_lwps ();
918 else if (thread_db_find_new_threads_silently (inferior_thread ()) != 0)
920 /* Even if libthread_db initializes, if the thread list is
921 corrupted, we'd not manage to list any threads. Better reject this
922 thread_db, and fall back to at least listing LWPs. */
926 printf_unfiltered (_("[Thread debugging using libthread_db enabled]\n"));
928 if (*libthread_db_search_path
|| libthread_db_debug
)
930 struct ui_file
*file
;
933 library
= dladdr_to_soname ((const void *) *info
->td_ta_new_p
);
935 library
= LIBTHREAD_DB_SO
;
937 /* If we'd print this to gdb_stdout when debug output is
938 disabled, still print it to gdb_stdout if debug output is
939 enabled. User visible output should not depend on debug
941 file
= *libthread_db_search_path
!= '\0' ? gdb_stdout
: gdb_stdlog
;
942 fprintf_unfiltered (file
,
943 _("Using host libthread_db library \"%ps\".\n"),
944 styled_string (file_name_style
.style (), library
));
947 /* The thread library was detected. Activate the thread_db target
949 push_target (&the_thread_db_target
);
953 /* Attempt to use LIBRARY as libthread_db. LIBRARY could be absolute,
954 relative, or just LIBTHREAD_DB. */
957 try_thread_db_load (const char *library
, bool check_auto_load_safe
)
960 struct thread_db_info
*info
;
962 if (libthread_db_debug
)
963 fprintf_unfiltered (gdb_stdlog
,
964 _("Trying host libthread_db library: %s.\n"),
967 if (check_auto_load_safe
)
969 if (access (library
, R_OK
) != 0)
971 /* Do not print warnings by file_is_auto_load_safe if the library does
972 not exist at this place. */
973 if (libthread_db_debug
)
974 fprintf_unfiltered (gdb_stdlog
, _("open failed: %s.\n"),
975 safe_strerror (errno
));
979 auto_load_debug_printf
980 ("Loading libthread-db library \"%s\" from explicit directory.",
983 if (!file_is_auto_load_safe (library
))
987 handle
= dlopen (library
, RTLD_NOW
);
990 if (libthread_db_debug
)
991 fprintf_unfiltered (gdb_stdlog
, _("dlopen failed: %s.\n"), dlerror ());
995 if (libthread_db_debug
&& strchr (library
, '/') == NULL
)
999 td_init
= dlsym (handle
, "td_init");
1000 if (td_init
!= NULL
)
1002 const char *const libpath
= dladdr_to_soname (td_init
);
1004 if (libpath
!= NULL
)
1005 fprintf_unfiltered (gdb_stdlog
, _("Host %s resolved to: %s.\n"),
1010 info
= add_thread_db_info (handle
);
1012 /* Do not save system library name, that one is always trusted. */
1013 if (strchr (library
, '/') != NULL
)
1014 info
->filename
= gdb_realpath (library
).release ();
1016 if (try_thread_db_load_1 (info
))
1019 /* This library "refused" to work on current inferior. */
1020 delete_thread_db_info (current_inferior ()->process_target (),
1021 inferior_ptid
.pid ());
1025 /* Subroutine of try_thread_db_load_from_pdir to simplify it.
1026 Try loading libthread_db in directory(OBJ)/SUBDIR.
1027 SUBDIR may be NULL. It may also be something like "../lib64".
1028 The result is true for success. */
1031 try_thread_db_load_from_pdir_1 (struct objfile
*obj
, const char *subdir
)
1033 const char *obj_name
= objfile_name (obj
);
1035 if (obj_name
[0] != '/')
1037 warning (_("Expected absolute pathname for libpthread in the"
1038 " inferior, but got %ps."),
1039 styled_string (file_name_style
.style (), obj_name
));
1043 std::string path
= obj_name
;
1044 size_t cp
= path
.rfind ('/');
1045 /* This should at minimum hit the first character. */
1046 gdb_assert (cp
!= std::string::npos
);
1047 path
.resize (cp
+ 1);
1049 path
= path
+ subdir
+ "/";
1050 path
+= LIBTHREAD_DB_SO
;
1052 return try_thread_db_load (path
.c_str (), true);
1055 /* Handle $pdir in libthread-db-search-path.
1056 Look for libthread_db in directory(libpthread)/SUBDIR.
1057 SUBDIR may be NULL. It may also be something like "../lib64".
1058 The result is true for success. */
1061 try_thread_db_load_from_pdir (const char *subdir
)
1063 if (!auto_load_thread_db
)
1066 for (objfile
*obj
: current_program_space
->objfiles ())
1067 if (libpthread_name_p (objfile_name (obj
)))
1069 if (try_thread_db_load_from_pdir_1 (obj
, subdir
))
1072 /* We may have found the separate-debug-info version of
1073 libpthread, and it may live in a directory without a matching
1075 if (obj
->separate_debug_objfile_backlink
!= NULL
)
1076 return try_thread_db_load_from_pdir_1 (obj
->separate_debug_objfile_backlink
,
1085 /* Handle $sdir in libthread-db-search-path.
1086 Look for libthread_db in the system dirs, or wherever a plain
1087 dlopen(file_without_path) will look.
1088 The result is true for success. */
1091 try_thread_db_load_from_sdir (void)
1093 return try_thread_db_load (LIBTHREAD_DB_SO
, false);
1096 /* Try to load libthread_db from directory DIR of length DIR_LEN.
1097 The result is true for success. */
1100 try_thread_db_load_from_dir (const char *dir
, size_t dir_len
)
1102 if (!auto_load_thread_db
)
1105 std::string path
= std::string (dir
, dir_len
) + "/" + LIBTHREAD_DB_SO
;
1107 return try_thread_db_load (path
.c_str (), true);
1110 /* Search libthread_db_search_path for libthread_db which "agrees"
1111 to work on current inferior.
1112 The result is true for success. */
1115 thread_db_load_search (void)
1119 std::vector
<gdb::unique_xmalloc_ptr
<char>> dir_vec
1120 = dirnames_to_char_ptr_vec (libthread_db_search_path
);
1122 for (const gdb::unique_xmalloc_ptr
<char> &this_dir_up
: dir_vec
)
1124 const char *this_dir
= this_dir_up
.get ();
1125 const int pdir_len
= sizeof ("$pdir") - 1;
1126 size_t this_dir_len
;
1128 this_dir_len
= strlen (this_dir
);
1130 if (strncmp (this_dir
, "$pdir", pdir_len
) == 0
1131 && (this_dir
[pdir_len
] == '\0'
1132 || this_dir
[pdir_len
] == '/'))
1134 const char *subdir
= NULL
;
1136 std::string subdir_holder
;
1137 if (this_dir
[pdir_len
] == '/')
1139 subdir_holder
= std::string (this_dir
+ pdir_len
+ 1);
1140 subdir
= subdir_holder
.c_str ();
1142 rc
= try_thread_db_load_from_pdir (subdir
);
1146 else if (strcmp (this_dir
, "$sdir") == 0)
1148 if (try_thread_db_load_from_sdir ())
1156 if (try_thread_db_load_from_dir (this_dir
, this_dir_len
))
1164 if (libthread_db_debug
)
1165 fprintf_unfiltered (gdb_stdlog
,
1166 _("thread_db_load_search returning %d\n"), rc
);
1170 /* Return true if the inferior has a libpthread. */
1173 has_libpthread (void)
1175 for (objfile
*obj
: current_program_space
->objfiles ())
1176 if (libpthread_name_p (objfile_name (obj
)))
1182 /* Attempt to load and initialize libthread_db.
1183 Return 1 on success. */
1186 thread_db_load (void)
1188 struct thread_db_info
*info
;
1190 info
= get_thread_db_info (current_inferior ()->process_target (),
1191 inferior_ptid
.pid ());
1196 /* Don't attempt to use thread_db on executables not running
1198 if (!target_has_registers ())
1201 /* Don't attempt to use thread_db for remote targets. */
1202 if (!(target_can_run () || core_bfd
))
1205 if (thread_db_load_search ())
1208 /* We couldn't find a libthread_db.
1209 If the inferior has a libpthread warn the user. */
1210 if (has_libpthread ())
1212 warning (_("Unable to find libthread_db matching inferior's thread"
1213 " library, thread debugging will not be available."));
1217 /* Either this executable isn't using libpthread at all, or it is
1218 statically linked. Since we can't easily distinguish these two cases,
1219 no warning is issued. */
1224 check_thread_signals (void)
1226 if (!thread_signals
)
1231 lin_thread_get_thread_signals (&mask
);
1232 sigemptyset (&thread_stop_set
);
1233 sigemptyset (&thread_print_set
);
1235 for (i
= 1; i
< NSIG
; i
++)
1237 if (sigismember (&mask
, i
))
1239 if (signal_stop_update (gdb_signal_from_host (i
), 0))
1240 sigaddset (&thread_stop_set
, i
);
1241 if (signal_print_update (gdb_signal_from_host (i
), 0))
1242 sigaddset (&thread_print_set
, i
);
1249 /* Check whether thread_db is usable. This function is called when
1250 an inferior is created (or otherwise acquired, e.g. attached to)
1251 and when new shared libraries are loaded into a running process. */
1254 check_for_thread_db (void)
1256 /* Do nothing if we couldn't load libthread_db.so.1. */
1257 if (!thread_db_load ())
1261 /* This function is called via the new_objfile observer. */
1264 thread_db_new_objfile (struct objfile
*objfile
)
1266 /* This observer must always be called with inferior_ptid set
1270 /* libpthread with separate debug info has its debug info file already
1271 loaded (and notified without successful thread_db initialization)
1272 the time gdb::observers::new_objfile.notify is called for the library itself.
1273 Static executables have their separate debug info loaded already
1274 before the inferior has started. */
1275 && objfile
->separate_debug_objfile_backlink
== NULL
1276 /* Only check for thread_db if we loaded libpthread,
1277 or if this is the main symbol file.
1278 We need to check OBJF_MAINLINE to handle the case of debugging
1279 a statically linked executable AND the symbol file is specified AFTER
1280 the exec file is loaded (e.g., gdb -c core ; file foo).
1281 For dynamically linked executables, libpthread can be near the end
1282 of the list of shared libraries to load, and in an app of several
1283 thousand shared libraries, this can otherwise be painful. */
1284 && ((objfile
->flags
& OBJF_MAINLINE
) != 0
1285 || libpthread_name_p (objfile_name (objfile
))))
1286 check_for_thread_db ();
1290 check_pid_namespace_match (inferior
*inf
)
1292 /* Check is only relevant for local targets targets. */
1293 if (target_can_run ())
1295 /* If the child is in a different PID namespace, its idea of its
1296 PID will differ from our idea of its PID. When we scan the
1297 child's thread list, we'll mistakenly think it has no threads
1298 since the thread PID fields won't match the PID we give to
1300 if (!linux_ns_same (inf
->pid
, LINUX_NS_PID
))
1302 warning (_ ("Target and debugger are in different PID "
1303 "namespaces; thread lists and other data are "
1304 "likely unreliable. "
1305 "Connect to gdbserver inside the container."));
1310 /* This function is called via the inferior_created observer.
1311 This handles the case of debugging statically linked executables. */
1314 thread_db_inferior_created (inferior
*inf
)
1316 check_pid_namespace_match (inf
);
1317 check_for_thread_db ();
1320 /* Update the thread's state (what's displayed in "info threads"),
1321 from libthread_db thread state information. */
1324 update_thread_state (thread_db_thread_info
*priv
,
1325 const td_thrinfo_t
*ti_p
)
1327 priv
->dying
= (ti_p
->ti_state
== TD_THR_UNKNOWN
1328 || ti_p
->ti_state
== TD_THR_ZOMBIE
);
1331 /* Record a new thread in GDB's thread list. Creates the thread's
1332 private info. If TP is NULL or TP is marked as having exited,
1333 creates a new thread. Otherwise, uses TP. */
1335 static struct thread_info
*
1336 record_thread (struct thread_db_info
*info
,
1337 struct thread_info
*tp
,
1338 ptid_t ptid
, const td_thrhandle_t
*th_p
,
1339 const td_thrinfo_t
*ti_p
)
1341 /* A thread ID of zero may mean the thread library has not
1342 initialized yet. Leave private == NULL until the thread library
1344 if (ti_p
->ti_tid
== 0)
1347 /* Construct the thread's private data. */
1348 thread_db_thread_info
*priv
= new thread_db_thread_info
;
1351 priv
->tid
= ti_p
->ti_tid
;
1352 update_thread_state (priv
, ti_p
);
1354 /* Add the thread to GDB's thread list. If we already know about a
1355 thread with this PTID, but it's marked exited, then the kernel
1356 reused the tid of an old thread. */
1357 if (tp
== NULL
|| tp
->state
== THREAD_EXITED
)
1358 tp
= add_thread_with_info (info
->process_target
, ptid
, priv
);
1360 tp
->priv
.reset (priv
);
1362 if (target_has_execution ())
1363 check_thread_signals ();
1369 thread_db_target::detach (inferior
*inf
, int from_tty
)
1371 delete_thread_db_info (inf
->process_target (), inf
->pid
);
1373 beneath ()->detach (inf
, from_tty
);
1375 /* NOTE: From this point on, inferior_ptid is null_ptid. */
1377 /* Detach the thread_db target from this inferior. */
1378 unpush_target (this);
1382 thread_db_target::wait (ptid_t ptid
, struct target_waitstatus
*ourstatus
,
1383 target_wait_flags options
)
1385 struct thread_db_info
*info
;
1387 process_stratum_target
*beneath
1388 = as_process_stratum_target (this->beneath ());
1390 ptid
= beneath
->wait (ptid
, ourstatus
, options
);
1392 switch (ourstatus
->kind
)
1394 case TARGET_WAITKIND_IGNORE
:
1395 case TARGET_WAITKIND_EXITED
:
1396 case TARGET_WAITKIND_THREAD_EXITED
:
1397 case TARGET_WAITKIND_SIGNALLED
:
1401 info
= get_thread_db_info (beneath
, ptid
.pid ());
1403 /* If this process isn't using thread_db, we're done. */
1407 if (ourstatus
->kind
== TARGET_WAITKIND_EXECD
)
1409 /* New image, it may or may not end up using thread_db. Assume
1410 not unless we find otherwise. */
1411 delete_thread_db_info (beneath
, ptid
.pid ());
1412 unpush_target (this);
1417 /* Fill in the thread's user-level thread id and status. */
1418 thread_from_lwp (find_thread_ptid (beneath
, ptid
), ptid
);
1424 thread_db_target::mourn_inferior ()
1426 process_stratum_target
*target_beneath
1427 = as_process_stratum_target (this->beneath ());
1429 delete_thread_db_info (target_beneath
, inferior_ptid
.pid ());
1431 target_beneath
->mourn_inferior ();
1433 /* Detach the thread_db target from this inferior. */
1434 unpush_target (this);
1437 struct callback_data
1439 struct thread_db_info
*info
;
1444 find_new_threads_callback (const td_thrhandle_t
*th_p
, void *data
)
1448 struct thread_info
*tp
;
1449 struct callback_data
*cb_data
= (struct callback_data
*) data
;
1450 struct thread_db_info
*info
= cb_data
->info
;
1452 err
= info
->td_thr_get_info_p (th_p
, &ti
);
1454 error (_("find_new_threads_callback: cannot get thread info: %s"),
1455 thread_db_err_str (err
));
1457 if (ti
.ti_lid
== -1)
1459 /* A thread with kernel thread ID -1 is either a thread that
1460 exited and was joined, or a thread that is being created but
1461 hasn't started yet, and that is reusing the tcb/stack of a
1462 thread that previously exited and was joined. (glibc marks
1463 terminated and joined threads with kernel thread ID -1. See
1465 if (libthread_db_debug
)
1466 fprintf_unfiltered (gdb_stdlog
,
1467 "thread_db: skipping exited and "
1468 "joined thread (0x%lx)\n",
1469 (unsigned long) ti
.ti_tid
);
1475 /* A thread ID of zero means that this is the main thread, but
1476 glibc has not yet initialized thread-local storage and the
1477 pthread library. We do not know what the thread's TID will
1480 /* In that case, we're not stopped in a fork syscall and don't
1481 need this glibc bug workaround. */
1482 info
->need_stale_parent_threads_check
= 0;
1487 /* Ignore stale parent threads, caused by glibc/BZ5983. This is a
1488 bit expensive, as it needs to open /proc/pid/status, so try to
1489 avoid doing the work if we know we don't have to. */
1490 if (info
->need_stale_parent_threads_check
)
1492 int tgid
= linux_proc_get_tgid (ti
.ti_lid
);
1494 if (tgid
!= -1 && tgid
!= info
->pid
)
1498 ptid_t
ptid (info
->pid
, ti
.ti_lid
);
1499 tp
= find_thread_ptid (info
->process_target
, ptid
);
1500 if (tp
== NULL
|| tp
->priv
== NULL
)
1501 record_thread (info
, tp
, ptid
, th_p
, &ti
);
1506 /* Helper for thread_db_find_new_threads_2.
1507 Returns number of new threads found. */
1510 find_new_threads_once (struct thread_db_info
*info
, int iteration
,
1513 struct callback_data data
;
1514 td_err_e err
= TD_ERR
;
1517 data
.new_threads
= 0;
1519 /* See comment in thread_db_update_thread_list. */
1520 gdb_assert (info
->td_ta_thr_iter_p
!= NULL
);
1524 /* Iterate over all user-space threads to discover new threads. */
1525 err
= info
->td_ta_thr_iter_p (info
->thread_agent
,
1526 find_new_threads_callback
,
1529 TD_THR_LOWEST_PRIORITY
,
1531 TD_THR_ANY_USER_FLAGS
);
1533 catch (const gdb_exception_error
&except
)
1535 if (libthread_db_debug
)
1537 exception_fprintf (gdb_stdlog
, except
,
1538 "Warning: find_new_threads_once: ");
1542 if (libthread_db_debug
)
1544 fprintf_unfiltered (gdb_stdlog
,
1545 _("Found %d new threads in iteration %d.\n"),
1546 data
.new_threads
, iteration
);
1552 return data
.new_threads
;
1555 /* Search for new threads, accessing memory through stopped thread
1556 PTID. If UNTIL_NO_NEW is true, repeat searching until several
1557 searches in a row do not discover any new threads. */
1560 thread_db_find_new_threads_2 (thread_info
*stopped
, bool until_no_new
)
1562 td_err_e err
= TD_OK
;
1563 struct thread_db_info
*info
;
1566 info
= get_thread_db_info (stopped
->inf
->process_target (),
1567 stopped
->ptid
.pid ());
1569 /* Access an lwp we know is stopped. */
1570 info
->proc_handle
.thread
= stopped
;
1574 /* Require 4 successive iterations which do not find any new threads.
1575 The 4 is a heuristic: there is an inherent race here, and I have
1576 seen that 2 iterations in a row are not always sufficient to
1577 "capture" all threads. */
1578 for (i
= 0, loop
= 0; loop
< 4 && err
== TD_OK
; ++i
, ++loop
)
1579 if (find_new_threads_once (info
, i
, &err
) != 0)
1581 /* Found some new threads. Restart the loop from beginning. */
1586 find_new_threads_once (info
, 0, &err
);
1589 error (_("Cannot find new threads: %s"), thread_db_err_str (err
));
1593 thread_db_find_new_threads_1 (thread_info
*stopped
)
1595 thread_db_find_new_threads_2 (stopped
, 0);
1598 /* Implement the to_update_thread_list target method for this
1602 thread_db_target::update_thread_list ()
1604 struct thread_db_info
*info
;
1608 for (inferior
*inf
: all_inferiors ())
1613 info
= get_thread_db_info (inf
->process_target (), inf
->pid
);
1617 thread_info
*thread
= any_live_thread_of_inferior (inf
);
1618 if (thread
== NULL
|| thread
->executing
)
1621 /* It's best to avoid td_ta_thr_iter if possible. That walks
1622 data structures in the inferior's address space that may be
1623 corrupted, or, if the target is running, the list may change
1624 while we walk it. In the latter case, it's possible that a
1625 thread exits just at the exact time that causes GDB to get
1626 stuck in an infinite loop. To avoid pausing all threads
1627 whenever the core wants to refresh the thread list, we
1628 instead use thread_from_lwp immediately when we see an LWP
1629 stop. That uses thread_db entry points that do not walk
1630 libpthread's thread list, so should be safe, as well as more
1632 if (thread
->inf
->has_execution ())
1635 thread_db_find_new_threads_1 (thread
);
1638 /* Give the beneath target a chance to do extra processing. */
1639 this->beneath ()->update_thread_list ();
1643 thread_db_target::pid_to_str (ptid_t ptid
)
1645 thread_info
*thread_info
= find_thread_ptid (current_inferior (), ptid
);
1647 if (thread_info
!= NULL
&& thread_info
->priv
!= NULL
)
1649 thread_db_thread_info
*priv
= get_thread_db_thread_info (thread_info
);
1651 return string_printf ("Thread 0x%lx (LWP %ld)",
1652 (unsigned long) priv
->tid
, ptid
.lwp ());
1655 return beneath ()->pid_to_str (ptid
);
1658 /* Return a string describing the state of the thread specified by
1662 thread_db_target::extra_thread_info (thread_info
*info
)
1664 if (info
->priv
== NULL
)
1667 thread_db_thread_info
*priv
= get_thread_db_thread_info (info
);
1675 /* Return pointer to the thread_info struct which corresponds to
1676 THREAD_HANDLE (having length HANDLE_LEN). */
1679 thread_db_target::thread_handle_to_thread_info (const gdb_byte
*thread_handle
,
1683 thread_t handle_tid
;
1685 /* When debugging a 32-bit target from a 64-bit host, handle_len
1686 will be 4 and sizeof (handle_tid) will be 8. This requires
1687 a different cast than the more straightforward case where
1688 the sizes are the same.
1690 Use "--target_board unix/-m32" from a native x86_64 linux build
1691 to test the 32/64-bit case. */
1692 if (handle_len
== 4 && sizeof (handle_tid
) == 8)
1693 handle_tid
= (thread_t
) * (const uint32_t *) thread_handle
;
1694 else if (handle_len
== sizeof (handle_tid
))
1695 handle_tid
= * (const thread_t
*) thread_handle
;
1697 error (_("Thread handle size mismatch: %d vs %zu (from libthread_db)"),
1698 handle_len
, sizeof (handle_tid
));
1700 for (thread_info
*tp
: inf
->non_exited_threads ())
1702 thread_db_thread_info
*priv
= get_thread_db_thread_info (tp
);
1704 if (priv
!= NULL
&& handle_tid
== priv
->tid
)
1711 /* Return the thread handle associated the thread_info pointer TP. */
1714 thread_db_target::thread_info_to_thread_handle (struct thread_info
*tp
)
1716 thread_db_thread_info
*priv
= get_thread_db_thread_info (tp
);
1719 return gdb::byte_vector ();
1721 int handle_size
= sizeof (priv
->tid
);
1722 gdb::byte_vector
rv (handle_size
);
1724 memcpy (rv
.data (), &priv
->tid
, handle_size
);
1729 /* Get the address of the thread local variable in load module LM which
1730 is stored at OFFSET within the thread local storage for thread PTID. */
1733 thread_db_target::get_thread_local_address (ptid_t ptid
,
1737 struct thread_info
*thread_info
;
1738 process_stratum_target
*beneath
1739 = as_process_stratum_target (this->beneath ());
1740 /* Find the matching thread. */
1741 thread_info
= find_thread_ptid (beneath
, ptid
);
1743 /* We may not have discovered the thread yet. */
1744 if (thread_info
!= NULL
&& thread_info
->priv
== NULL
)
1745 thread_info
= thread_from_lwp (thread_info
, ptid
);
1747 if (thread_info
!= NULL
&& thread_info
->priv
!= NULL
)
1751 thread_db_info
*info
= get_thread_db_info (beneath
, ptid
.pid ());
1752 thread_db_thread_info
*priv
= get_thread_db_thread_info (thread_info
);
1754 /* Finally, get the address of the variable. */
1757 /* glibc doesn't provide the needed interface. */
1758 if (!info
->td_thr_tls_get_addr_p
)
1759 throw_error (TLS_NO_LIBRARY_SUPPORT_ERROR
,
1760 _("No TLS library support"));
1762 /* Note the cast through uintptr_t: this interface only works if
1763 a target address fits in a psaddr_t, which is a host pointer.
1764 So a 32-bit debugger can not access 64-bit TLS through this. */
1765 err
= info
->td_thr_tls_get_addr_p (&priv
->th
,
1766 (psaddr_t
)(uintptr_t) lm
,
1771 /* If glibc doesn't provide the needed interface throw an error
1772 that LM is zero - normally cases it should not be. */
1773 if (!info
->td_thr_tlsbase_p
)
1774 throw_error (TLS_LOAD_MODULE_NOT_FOUND_ERROR
,
1775 _("TLS load module not found"));
1777 /* This code path handles the case of -static -pthread executables:
1778 https://sourceware.org/ml/libc-help/2014-03/msg00024.html
1779 For older GNU libc r_debug.r_map is NULL. For GNU libc after
1780 PR libc/16831 due to GDB PR threads/16954 LOAD_MODULE is also NULL.
1781 The constant number 1 depends on GNU __libc_setup_tls
1782 initialization of l_tls_modid to 1. */
1783 err
= info
->td_thr_tlsbase_p (&priv
->th
, 1, &address
);
1784 address
= (char *) address
+ offset
;
1787 #ifdef THREAD_DB_HAS_TD_NOTALLOC
1788 /* The memory hasn't been allocated, yet. */
1789 if (err
== TD_NOTALLOC
)
1790 /* Now, if libthread_db provided the initialization image's
1791 address, we *could* try to build a non-lvalue value from
1792 the initialization image. */
1793 throw_error (TLS_NOT_ALLOCATED_YET_ERROR
,
1794 _("TLS not allocated yet"));
1797 /* Something else went wrong. */
1799 throw_error (TLS_GENERIC_ERROR
,
1800 (("%s")), thread_db_err_str (err
));
1802 /* Cast assuming host == target. Joy. */
1803 /* Do proper sign extension for the target. */
1804 gdb_assert (current_program_space
->exec_bfd ());
1805 return (bfd_get_sign_extend_vma (current_program_space
->exec_bfd ()) > 0
1806 ? (CORE_ADDR
) (intptr_t) address
1807 : (CORE_ADDR
) (uintptr_t) address
);
1810 return beneath
->get_thread_local_address (ptid
, lm
, offset
);
1813 /* Implement the to_get_ada_task_ptid target method for this target. */
1816 thread_db_target::get_ada_task_ptid (long lwp
, long thread
)
1818 /* NPTL uses a 1:1 model, so the LWP id suffices. */
1819 return ptid_t (inferior_ptid
.pid (), lwp
, 0);
1823 thread_db_target::resume (ptid_t ptid
, int step
, enum gdb_signal signo
)
1825 process_stratum_target
*beneath
1826 = as_process_stratum_target (this->beneath ());
1828 thread_db_info
*info
1829 = get_thread_db_info (beneath
, (ptid
== minus_one_ptid
1830 ? inferior_ptid
.pid ()
1833 /* This workaround is only needed for child fork lwps stopped in a
1834 PTRACE_O_TRACEFORK event. When the inferior is resumed, the
1835 workaround can be disabled. */
1837 info
->need_stale_parent_threads_check
= 0;
1839 beneath
->resume (ptid
, step
, signo
);
1842 /* std::sort helper function for info_auto_load_libthread_db, sort the
1843 thread_db_info pointers primarily by their FILENAME and secondarily by their
1844 PID, both in ascending order. */
1847 info_auto_load_libthread_db_compare (const struct thread_db_info
*a
,
1848 const struct thread_db_info
*b
)
1852 retval
= strcmp (a
->filename
, b
->filename
);
1856 return a
->pid
< b
->pid
;
1859 /* Implement 'info auto-load libthread-db'. */
1862 info_auto_load_libthread_db (const char *args
, int from_tty
)
1864 struct ui_out
*uiout
= current_uiout
;
1865 const char *cs
= args
? args
: "";
1866 struct thread_db_info
*info
;
1867 unsigned unique_filenames
;
1868 size_t max_filename_len
, pids_len
;
1871 cs
= skip_spaces (cs
);
1873 error (_("'info auto-load libthread-db' does not accept any parameters"));
1875 std::vector
<struct thread_db_info
*> array
;
1876 for (info
= thread_db_list
; info
; info
= info
->next
)
1877 if (info
->filename
!= NULL
)
1878 array
.push_back (info
);
1880 /* Sort ARRAY by filenames and PIDs. */
1881 std::sort (array
.begin (), array
.end (),
1882 info_auto_load_libthread_db_compare
);
1884 /* Calculate the number of unique filenames (rows) and the maximum string
1885 length of PIDs list for the unique filenames (columns). */
1887 unique_filenames
= 0;
1888 max_filename_len
= 0;
1890 for (i
= 0; i
< array
.size (); i
++)
1892 int pid
= array
[i
]->pid
;
1893 size_t this_pid_len
;
1895 for (this_pid_len
= 0; pid
!= 0; pid
/= 10)
1898 if (i
== 0 || strcmp (array
[i
- 1]->filename
, array
[i
]->filename
) != 0)
1901 max_filename_len
= std::max (max_filename_len
,
1902 strlen (array
[i
]->filename
));
1905 pids_len
-= strlen (", ");
1908 pids_len
+= this_pid_len
+ strlen (", ");
1911 pids_len
-= strlen (", ");
1913 /* Table header shifted right by preceding "libthread-db: " would not match
1915 if (array
.size () > 0 && args
== auto_load_info_scripts_pattern_nl
)
1919 ui_out_emit_table
table_emitter (uiout
, 2, unique_filenames
,
1920 "LinuxThreadDbTable");
1922 uiout
->table_header (max_filename_len
, ui_left
, "filename", "Filename");
1923 uiout
->table_header (pids_len
, ui_left
, "PIDs", "Pids");
1924 uiout
->table_body ();
1926 /* Note I is incremented inside the cycle, not at its end. */
1927 for (i
= 0; i
< array
.size ();)
1929 ui_out_emit_tuple
tuple_emitter (uiout
, NULL
);
1932 uiout
->field_string ("filename", info
->filename
);
1935 while (i
< array
.size () && strcmp (info
->filename
,
1936 array
[i
]->filename
) == 0)
1940 string_appendf (pids
, "%u", array
[i
]->pid
);
1944 uiout
->field_string ("pids", pids
.c_str ());
1951 uiout
->message (_("No auto-loaded libthread-db.\n"));
1954 /* Implement 'maintenance check libthread-db'. */
1957 maintenance_check_libthread_db (const char *args
, int from_tty
)
1959 int inferior_pid
= inferior_ptid
.pid ();
1960 struct thread_db_info
*info
;
1962 if (inferior_pid
== 0)
1963 error (_("No inferior running"));
1965 info
= get_thread_db_info (current_inferior ()->process_target (),
1968 error (_("No libthread_db loaded"));
1970 check_thread_db (info
, true);
1973 void _initialize_thread_db ();
1975 _initialize_thread_db ()
1977 /* Defer loading of libthread_db.so until inferior is running.
1978 This allows gdb to load correct libthread_db for a given
1979 executable -- there could be multiple versions of glibc,
1980 and until there is a running inferior, we can't tell which
1981 libthread_db is the correct one to load. */
1983 libthread_db_search_path
= xstrdup (LIBTHREAD_DB_SEARCH_PATH
);
1985 add_setshow_optional_filename_cmd ("libthread-db-search-path",
1987 &libthread_db_search_path
, _("\
1988 Set search path for libthread_db."), _("\
1989 Show the current search path or libthread_db."), _("\
1990 This path is used to search for libthread_db to be loaded into \
1992 Its value is a colon (':') separate list of directories to search.\n\
1993 Setting the search path to an empty list resets it to its default value."),
1994 set_libthread_db_search_path
,
1996 &setlist
, &showlist
);
1998 add_setshow_zuinteger_cmd ("libthread-db", class_maintenance
,
1999 &libthread_db_debug
, _("\
2000 Set libthread-db debugging."), _("\
2001 Show libthread-db debugging."), _("\
2002 When non-zero, libthread-db debugging is enabled."),
2004 show_libthread_db_debug
,
2005 &setdebuglist
, &showdebuglist
);
2007 add_setshow_boolean_cmd ("libthread-db", class_support
,
2008 &auto_load_thread_db
, _("\
2009 Enable or disable auto-loading of inferior specific libthread_db."), _("\
2010 Show whether auto-loading inferior specific libthread_db is enabled."), _("\
2011 If enabled, libthread_db will be searched in 'set libthread-db-search-path'\n\
2012 locations to load libthread_db compatible with the inferior.\n\
2013 Standard system libthread_db still gets loaded even with this option off.\n\
2014 This option has security implications for untrusted inferiors."),
2015 NULL
, show_auto_load_thread_db
,
2016 auto_load_set_cmdlist_get (),
2017 auto_load_show_cmdlist_get ());
2019 add_cmd ("libthread-db", class_info
, info_auto_load_libthread_db
,
2020 _("Print the list of loaded inferior specific libthread_db.\n\
2021 Usage: info auto-load libthread-db"),
2022 auto_load_info_cmdlist_get ());
2024 add_cmd ("libthread-db", class_maintenance
,
2025 maintenance_check_libthread_db
, _("\
2026 Run integrity checks on the current inferior's libthread_db."),
2027 &maintenancechecklist
);
2029 add_setshow_boolean_cmd ("check-libthread-db",
2031 &check_thread_db_on_load
, _("\
2032 Set whether to check libthread_db at load time."), _("\
2033 Show whether to check libthread_db at load time."), _("\
2034 If enabled GDB will run integrity checks on inferior specific libthread_db\n\
2035 as they are loaded."),
2038 &maintenance_set_cmdlist
,
2039 &maintenance_show_cmdlist
);
2041 /* Add ourselves to objfile event chain. */
2042 gdb::observers::new_objfile
.attach (thread_db_new_objfile
);
2044 /* Add ourselves to inferior_created event chain.
2045 This is needed to handle debugging statically linked programs where
2046 the new_objfile observer won't get called for libpthread. */
2047 gdb::observers::inferior_created
.attach (thread_db_inferior_created
);