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