1 /* Thread management interface, for the remote server for GDB.
2 Copyright (C) 2002-2022 Free Software Foundation, Inc.
4 Contributed by MontaVista Software.
6 This file is part of GDB.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program. If not, see <http://www.gnu.org/licenses/>. */
23 #include "linux-low.h"
26 #include "gdb_proc_service.h"
27 #include "nat/gdb_thread_db.h"
28 #include "gdbsupport/gdb_vecs.h"
29 #include "nat/linux-procfs.h"
30 #include "gdbsupport/scoped_restore.h"
32 #ifndef USE_LIBTHREAD_DB_DIRECTLY
40 /* Structure that identifies the child process for the
41 <proc_service.h> interface. */
42 struct ps_prochandle proc_handle
;
44 /* Connection to the libthread_db library. */
45 td_thragent_t
*thread_agent
;
47 /* If this flag has been set, we've already asked GDB for all
48 symbols we might need; assume symbol cache misses are
50 int all_symbols_looked_up
;
52 #ifndef USE_LIBTHREAD_DB_DIRECTLY
53 /* Handle of the libthread_db from dlopen. */
57 /* Addresses of libthread_db functions. */
58 td_ta_new_ftype
*td_ta_new_p
;
59 td_ta_map_lwp2thr_ftype
*td_ta_map_lwp2thr_p
;
60 td_thr_get_info_ftype
*td_thr_get_info_p
;
61 td_ta_thr_iter_ftype
*td_ta_thr_iter_p
;
62 td_thr_tls_get_addr_ftype
*td_thr_tls_get_addr_p
;
63 td_thr_tlsbase_ftype
*td_thr_tlsbase_p
;
64 td_symbol_list_ftype
*td_symbol_list_p
;
67 static char *libthread_db_search_path
;
69 static int find_one_thread (ptid_t
);
70 static int find_new_threads_callback (const td_thrhandle_t
*th_p
, void *data
);
73 thread_db_err_str (td_err_e err
)
80 return "generic 'call succeeded'";
82 return "generic error";
84 return "no thread to satisfy query";
86 return "no sync handle to satisfy query";
88 return "no LWP to satisfy query";
90 return "invalid process handle";
92 return "invalid thread handle";
94 return "invalid synchronization handle";
96 return "invalid thread agent";
100 return "no event message for getmsg";
102 return "FPU register set not available";
104 return "application not linked with libthread";
106 return "requested event is not supported";
108 return "capability not available";
110 return "debugger service failed";
112 return "operation not applicable to";
114 return "no thread-specific data for this thread";
116 return "malloc failed";
118 return "only part of register set was written/read";
120 return "X register set not available for this thread";
121 #ifdef HAVE_TD_VERSION
123 return "version mismatch between libthread_db and libpthread";
126 xsnprintf (buf
, sizeof (buf
), "unknown thread_db error '%d'", err
);
133 thread_db_state_str (td_thr_state_e state
)
140 return "stopped by debugger";
149 case TD_THR_STOPPED_ASLEEP
:
150 return "stopped by debugger AND blocked";
152 xsnprintf (buf
, sizeof (buf
), "unknown thread_db state %d", state
);
158 /* Get thread info about PTID, accessing memory via the current
162 find_one_thread (ptid_t ptid
)
167 struct lwp_info
*lwp
;
168 struct thread_db
*thread_db
= current_process ()->priv
->thread_db
;
169 int lwpid
= ptid
.lwp ();
171 thread_info
*thread
= find_thread_ptid (ptid
);
172 lwp
= get_thread_lwp (thread
);
173 if (lwp
->thread_known
)
176 /* Get information about this thread. */
177 err
= thread_db
->td_ta_map_lwp2thr_p (thread_db
->thread_agent
, lwpid
, &th
);
179 error ("Cannot get thread handle for LWP %d: %s",
180 lwpid
, thread_db_err_str (err
));
182 err
= thread_db
->td_thr_get_info_p (&th
, &ti
);
184 error ("Cannot get thread info for LWP %d: %s",
185 lwpid
, thread_db_err_str (err
));
188 debug_printf ("Found thread %ld (LWP %d)\n",
189 (unsigned long) ti
.ti_tid
, ti
.ti_lid
);
191 if (lwpid
!= ti
.ti_lid
)
193 warning ("PID mismatch! Expected %ld, got %ld",
194 (long) lwpid
, (long) ti
.ti_lid
);
198 /* If the new thread ID is zero, a final thread ID will be available
199 later. Do not enable thread debugging yet. */
203 lwp
->thread_known
= 1;
205 lwp
->thread_handle
= ti
.ti_tid
;
210 /* Attach a thread. Return true on success. */
213 attach_thread (const td_thrhandle_t
*th_p
, td_thrinfo_t
*ti_p
)
215 struct process_info
*proc
= current_process ();
216 int pid
= pid_of (proc
);
217 ptid_t ptid
= ptid_t (pid
, ti_p
->ti_lid
);
218 struct lwp_info
*lwp
;
222 debug_printf ("Attaching to thread %ld (LWP %d)\n",
223 (unsigned long) ti_p
->ti_tid
, ti_p
->ti_lid
);
224 err
= the_linux_target
->attach_lwp (ptid
);
227 std::string reason
= linux_ptrace_attach_fail_reason_string (ptid
, err
);
229 warning ("Could not attach to thread %ld (LWP %d): %s",
230 (unsigned long) ti_p
->ti_tid
, ti_p
->ti_lid
, reason
.c_str ());
235 lwp
= find_lwp_pid (ptid
);
236 gdb_assert (lwp
!= NULL
);
237 lwp
->thread_known
= 1;
239 lwp
->thread_handle
= ti_p
->ti_tid
;
244 /* Attach thread if we haven't seen it yet.
245 Increment *COUNTER if we have attached a new thread.
246 Return false on failure. */
249 maybe_attach_thread (const td_thrhandle_t
*th_p
, td_thrinfo_t
*ti_p
,
252 struct lwp_info
*lwp
;
254 lwp
= find_lwp_pid (ptid_t (ti_p
->ti_lid
));
258 if (!attach_thread (th_p
, ti_p
))
268 find_new_threads_callback (const td_thrhandle_t
*th_p
, void *data
)
272 struct thread_db
*thread_db
= current_process ()->priv
->thread_db
;
274 err
= thread_db
->td_thr_get_info_p (th_p
, &ti
);
276 error ("Cannot get thread info: %s", thread_db_err_str (err
));
280 /* A thread with kernel thread ID -1 is either a thread that
281 exited and was joined, or a thread that is being created but
282 hasn't started yet, and that is reusing the tcb/stack of a
283 thread that previously exited and was joined. (glibc marks
284 terminated and joined threads with kernel thread ID -1. See
287 debug_printf ("thread_db: skipping exited and "
288 "joined thread (0x%lx)\n",
289 (unsigned long) ti
.ti_tid
);
293 /* Check for zombies. */
294 if (ti
.ti_state
== TD_THR_UNKNOWN
|| ti
.ti_state
== TD_THR_ZOMBIE
)
297 if (!maybe_attach_thread (th_p
, &ti
, (int *) data
))
299 /* Terminate iteration early: we might be looking at stale data in
300 the inferior. The thread_db_find_new_threads will retry. */
308 thread_db_find_new_threads (void)
311 ptid_t ptid
= current_ptid
;
312 struct thread_db
*thread_db
= current_process ()->priv
->thread_db
;
315 /* This function is only called when we first initialize thread_db.
316 First locate the initial thread. If it is not ready for
317 debugging yet, then stop. */
318 if (find_one_thread (ptid
) == 0)
321 /* Require 4 successive iterations which do not find any new threads.
322 The 4 is a heuristic: there is an inherent race here, and I have
323 seen that 2 iterations in a row are not always sufficient to
324 "capture" all threads. */
325 for (loop
= 0, iteration
= 0; loop
< 4; ++loop
, ++iteration
)
327 int new_thread_count
= 0;
329 /* Iterate over all user-space threads to discover new threads. */
330 err
= thread_db
->td_ta_thr_iter_p (thread_db
->thread_agent
,
331 find_new_threads_callback
,
334 TD_THR_LOWEST_PRIORITY
,
335 TD_SIGNO_MASK
, TD_THR_ANY_USER_FLAGS
);
337 debug_printf ("Found %d threads in iteration %d.\n",
338 new_thread_count
, iteration
);
340 if (new_thread_count
!= 0)
342 /* Found new threads. Restart iteration from beginning. */
347 error ("Cannot find new threads: %s", thread_db_err_str (err
));
350 /* Cache all future symbols that thread_db might request. We can not
351 request symbols at arbitrary states in the remote protocol, only
352 when the client tells us that new symbols are available. So when
353 we load the thread library, make sure to check the entire list. */
356 thread_db_look_up_symbols (void)
358 struct thread_db
*thread_db
= current_process ()->priv
->thread_db
;
359 const char **sym_list
;
362 for (sym_list
= thread_db
->td_symbol_list_p (); *sym_list
; sym_list
++)
363 look_up_one_symbol (*sym_list
, &unused
, 1);
365 /* We're not interested in any other libraries loaded after this
366 point, only in symbols in libpthread.so. */
367 thread_db
->all_symbols_looked_up
= 1;
371 thread_db_look_up_one_symbol (const char *name
, CORE_ADDR
*addrp
)
373 struct thread_db
*thread_db
= current_process ()->priv
->thread_db
;
374 int may_ask_gdb
= !thread_db
->all_symbols_looked_up
;
376 /* If we've passed the call to thread_db_look_up_symbols, then
377 anything not in the cache must not exist; we're not interested
378 in any libraries loaded after that point, only in symbols in
379 libpthread.so. It might not be an appropriate time to look
380 up a symbol, e.g. while we're trying to fetch registers. */
381 return look_up_one_symbol (name
, addrp
, may_ask_gdb
);
385 thread_db_get_tls_address (struct thread_info
*thread
, CORE_ADDR offset
,
386 CORE_ADDR load_module
, CORE_ADDR
*address
)
390 struct lwp_info
*lwp
;
391 struct process_info
*proc
;
392 struct thread_db
*thread_db
;
394 proc
= get_thread_process (thread
);
395 thread_db
= proc
->priv
->thread_db
;
397 /* If the thread layer is not (yet) initialized, fail. */
398 if (thread_db
== NULL
|| !thread_db
->all_symbols_looked_up
)
401 /* If td_thr_tls_get_addr is missing rather do not expect td_thr_tlsbase
403 if (thread_db
->td_thr_tls_get_addr_p
== NULL
404 || (load_module
== 0 && thread_db
->td_thr_tlsbase_p
== NULL
))
407 lwp
= get_thread_lwp (thread
);
408 if (!lwp
->thread_known
)
409 find_one_thread (thread
->id
);
410 if (!lwp
->thread_known
)
413 scoped_restore_current_thread restore_thread
;
414 switch_to_thread (thread
);
416 if (load_module
!= 0)
418 /* Note the cast through uintptr_t: this interface only works if
419 a target address fits in a psaddr_t, which is a host pointer.
420 So a 32-bit debugger can not access 64-bit TLS through this. */
421 err
= thread_db
->td_thr_tls_get_addr_p (&lwp
->th
,
422 (psaddr_t
) (uintptr_t) load_module
,
427 /* This code path handles the case of -static -pthread executables:
428 https://sourceware.org/ml/libc-help/2014-03/msg00024.html
429 For older GNU libc r_debug.r_map is NULL. For GNU libc after
430 PR libc/16831 due to GDB PR threads/16954 LOAD_MODULE is also NULL.
431 The constant number 1 depends on GNU __libc_setup_tls
432 initialization of l_tls_modid to 1. */
433 err
= thread_db
->td_thr_tlsbase_p (&lwp
->th
, 1, &addr
);
434 addr
= (char *) addr
+ offset
;
439 *address
= (CORE_ADDR
) (uintptr_t) addr
;
446 /* See linux-low.h. */
449 thread_db_thread_handle (ptid_t ptid
, gdb_byte
**handle
, int *handle_len
)
451 struct thread_db
*thread_db
;
452 struct lwp_info
*lwp
;
453 thread_info
*thread
= find_thread_ptid (ptid
);
458 thread_db
= get_thread_process (thread
)->priv
->thread_db
;
460 if (thread_db
== NULL
)
463 lwp
= get_thread_lwp (thread
);
465 if (!lwp
->thread_known
&& !find_one_thread (thread
->id
))
468 gdb_assert (lwp
->thread_known
);
470 *handle
= (gdb_byte
*) &lwp
->thread_handle
;
471 *handle_len
= sizeof (lwp
->thread_handle
);
475 #ifdef USE_LIBTHREAD_DB_DIRECTLY
478 thread_db_load_search (void)
481 struct thread_db
*tdb
;
482 struct process_info
*proc
= current_process ();
484 gdb_assert (proc
->priv
->thread_db
== NULL
);
486 tdb
= XCNEW (struct thread_db
);
487 proc
->priv
->thread_db
= tdb
;
489 tdb
->td_ta_new_p
= &td_ta_new
;
491 /* Attempt to open a connection to the thread library. */
492 err
= tdb
->td_ta_new_p (&tdb
->proc_handle
, &tdb
->thread_agent
);
496 debug_printf ("td_ta_new(): %s\n", thread_db_err_str (err
));
498 proc
->priv
->thread_db
= NULL
;
502 tdb
->td_ta_map_lwp2thr_p
= &td_ta_map_lwp2thr
;
503 tdb
->td_thr_get_info_p
= &td_thr_get_info
;
504 tdb
->td_ta_thr_iter_p
= &td_ta_thr_iter
;
505 tdb
->td_symbol_list_p
= &td_symbol_list
;
507 /* These are not essential. */
508 tdb
->td_thr_tls_get_addr_p
= &td_thr_tls_get_addr
;
509 tdb
->td_thr_tlsbase_p
= &td_thr_tlsbase
;
517 try_thread_db_load_1 (void *handle
)
520 struct thread_db
*tdb
;
521 struct process_info
*proc
= current_process ();
523 gdb_assert (proc
->priv
->thread_db
== NULL
);
525 tdb
= XCNEW (struct thread_db
);
526 proc
->priv
->thread_db
= tdb
;
528 tdb
->handle
= handle
;
530 /* Initialize pointers to the dynamic library functions we will use.
531 Essential functions first. */
533 #define CHK(required, a) \
539 debug_printf ("dlsym: %s\n", dlerror ()); \
543 proc->priv->thread_db = NULL; \
550 #define TDB_DLSYM(tdb, func) \
551 tdb->func ## _p = (func ## _ftype *) dlsym (tdb->handle, #func)
553 CHK (1, TDB_DLSYM (tdb
, td_ta_new
));
555 /* Attempt to open a connection to the thread library. */
556 err
= tdb
->td_ta_new_p (&tdb
->proc_handle
, &tdb
->thread_agent
);
560 debug_printf ("td_ta_new(): %s\n", thread_db_err_str (err
));
562 proc
->priv
->thread_db
= NULL
;
566 CHK (1, TDB_DLSYM (tdb
, td_ta_map_lwp2thr
));
567 CHK (1, TDB_DLSYM (tdb
, td_thr_get_info
));
568 CHK (1, TDB_DLSYM (tdb
, td_ta_thr_iter
));
569 CHK (1, TDB_DLSYM (tdb
, td_symbol_list
));
571 /* These are not essential. */
572 CHK (0, TDB_DLSYM (tdb
, td_thr_tls_get_addr
));
573 CHK (0, TDB_DLSYM (tdb
, td_thr_tlsbase
));
583 /* Lookup a library in which given symbol resides.
584 Note: this is looking in the GDBSERVER process, not in the inferior.
585 Returns library name, or NULL. */
588 dladdr_to_soname (const void *addr
)
592 if (dladdr (addr
, &info
) != 0)
593 return info
.dli_fname
;
600 try_thread_db_load (const char *library
)
605 debug_printf ("Trying host libthread_db library: %s.\n",
607 handle
= dlopen (library
, RTLD_NOW
);
611 debug_printf ("dlopen failed: %s.\n", dlerror ());
616 if (debug_threads
&& strchr (library
, '/') == NULL
)
620 td_init
= dlsym (handle
, "td_init");
623 const char *const libpath
= dladdr_to_soname (td_init
);
626 debug_printf ("Host %s resolved to: %s.\n", library
, libpath
);
631 if (try_thread_db_load_1 (handle
))
634 /* This library "refused" to work on current inferior. */
639 /* Handle $sdir in libthread-db-search-path.
640 Look for libthread_db in the system dirs, or wherever a plain
641 dlopen(file_without_path) will look.
642 The result is true for success. */
645 try_thread_db_load_from_sdir (void)
647 return try_thread_db_load (LIBTHREAD_DB_SO
);
650 /* Try to load libthread_db from directory DIR of length DIR_LEN.
651 The result is true for success. */
654 try_thread_db_load_from_dir (const char *dir
, size_t dir_len
)
658 if (dir_len
+ 1 + strlen (LIBTHREAD_DB_SO
) + 1 > sizeof (path
))
660 char *cp
= (char *) xmalloc (dir_len
+ 1);
662 memcpy (cp
, dir
, dir_len
);
664 warning (_("libthread-db-search-path component too long,"
665 " ignored: %s."), cp
);
670 memcpy (path
, dir
, dir_len
);
672 strcpy (path
+ dir_len
+ 1, LIBTHREAD_DB_SO
);
673 return try_thread_db_load (path
);
676 /* Search libthread_db_search_path for libthread_db which "agrees"
677 to work on current inferior.
678 The result is true for success. */
681 thread_db_load_search (void)
685 if (libthread_db_search_path
== NULL
)
686 libthread_db_search_path
= xstrdup (LIBTHREAD_DB_SEARCH_PATH
);
688 std::vector
<gdb::unique_xmalloc_ptr
<char>> dir_vec
689 = dirnames_to_char_ptr_vec (libthread_db_search_path
);
691 for (const gdb::unique_xmalloc_ptr
<char> &this_dir_up
: dir_vec
)
693 char *this_dir
= this_dir_up
.get ();
694 const int pdir_len
= sizeof ("$pdir") - 1;
697 this_dir_len
= strlen (this_dir
);
699 if (strncmp (this_dir
, "$pdir", pdir_len
) == 0
700 && (this_dir
[pdir_len
] == '\0'
701 || this_dir
[pdir_len
] == '/'))
703 /* We don't maintain a list of loaded libraries so we don't know
704 where libpthread lives. We *could* fetch the info, but we don't
705 do that yet. Ignore it. */
707 else if (strcmp (this_dir
, "$sdir") == 0)
709 if (try_thread_db_load_from_sdir ())
717 if (try_thread_db_load_from_dir (this_dir
, this_dir_len
))
726 debug_printf ("thread_db_load_search returning %d\n", rc
);
730 #endif /* USE_LIBTHREAD_DB_DIRECTLY */
733 thread_db_init (void)
735 struct process_info
*proc
= current_process ();
737 /* FIXME drow/2004-10-16: This is the "overall process ID", which
738 GNU/Linux calls tgid, "thread group ID". When we support
739 attaching to threads, the original thread may not be the correct
740 thread. We would have to get the process ID from /proc for NPTL.
742 This isn't the only place in gdbserver that assumes that the first
743 process in the list is the thread group leader. */
745 if (thread_db_load_search ())
747 /* It's best to avoid td_ta_thr_iter if possible. That walks
748 data structures in the inferior's address space that may be
749 corrupted, or, if the target is running, the list may change
750 while we walk it. In the latter case, it's possible that a
751 thread exits just at the exact time that causes GDBserver to
752 get stuck in an infinite loop. As the kernel supports clone
753 events and /proc/PID/task/ exists, then we already know about
754 all threads in the process. When we need info out of
755 thread_db on a given thread (e.g., for TLS), we'll use
756 find_one_thread then. That uses thread_db entry points that
757 do not walk libpthread's thread list, so should be safe, as
758 well as more efficient. */
759 if (!linux_proc_task_list_dir_exists (pid_of (proc
)))
760 thread_db_find_new_threads ();
761 thread_db_look_up_symbols ();
768 /* Disconnect from libthread_db and free resources. */
771 disable_thread_event_reporting (struct process_info
*proc
)
773 struct thread_db
*thread_db
= proc
->priv
->thread_db
;
776 td_err_e (*td_ta_clear_event_p
) (const td_thragent_t
*ta
,
777 td_thr_events_t
*event
);
779 #ifndef USE_LIBTHREAD_DB_DIRECTLY
781 = (td_ta_clear_event_ftype
*) dlsym (thread_db
->handle
,
782 "td_ta_clear_event");
784 td_ta_clear_event_p
= &td_ta_clear_event
;
787 if (td_ta_clear_event_p
!= NULL
)
789 scoped_restore_current_thread restore_thread
;
790 td_thr_events_t events
;
792 switch_to_process (proc
);
794 /* Set the process wide mask saying we aren't interested
795 in any events anymore. */
796 td_event_fillset (&events
);
797 (*td_ta_clear_event_p
) (thread_db
->thread_agent
, &events
);
803 thread_db_detach (struct process_info
*proc
)
805 struct thread_db
*thread_db
= proc
->priv
->thread_db
;
809 disable_thread_event_reporting (proc
);
813 /* Disconnect from libthread_db and free resources. */
816 thread_db_mourn (struct process_info
*proc
)
818 struct thread_db
*thread_db
= proc
->priv
->thread_db
;
821 td_ta_delete_ftype
*td_ta_delete_p
;
823 #ifndef USE_LIBTHREAD_DB_DIRECTLY
824 td_ta_delete_p
= (td_ta_delete_ftype
*) dlsym (thread_db
->handle
, "td_ta_delete");
826 td_ta_delete_p
= &td_ta_delete
;
829 if (td_ta_delete_p
!= NULL
)
830 (*td_ta_delete_p
) (thread_db
->thread_agent
);
832 #ifndef USE_LIBTHREAD_DB_DIRECTLY
833 dlclose (thread_db
->handle
);
834 #endif /* USE_LIBTHREAD_DB_DIRECTLY */
837 proc
->priv
->thread_db
= NULL
;
841 /* Handle "set libthread-db-search-path" monitor command and return 1.
842 For any other command, return 0. */
845 thread_db_handle_monitor_command (char *mon
)
847 const char *cmd
= "set libthread-db-search-path";
848 size_t cmd_len
= strlen (cmd
);
850 if (strncmp (mon
, cmd
, cmd_len
) == 0
851 && (mon
[cmd_len
] == '\0'
852 || mon
[cmd_len
] == ' '))
854 const char *cp
= mon
+ cmd_len
;
856 if (libthread_db_search_path
!= NULL
)
857 free (libthread_db_search_path
);
859 /* Skip leading space (if any). */
860 while (isspace (*cp
))
864 cp
= LIBTHREAD_DB_SEARCH_PATH
;
865 libthread_db_search_path
= xstrdup (cp
);
867 monitor_output ("libthread-db-search-path set to `");
868 monitor_output (libthread_db_search_path
);
869 monitor_output ("'\n");
873 /* Tell server.c to perform default processing. */
877 /* See linux-low.h. */
880 thread_db_notice_clone (struct thread_info
*parent_thr
, ptid_t child_ptid
)
882 process_info
*parent_proc
= get_thread_process (parent_thr
);
883 struct thread_db
*thread_db
= parent_proc
->priv
->thread_db
;
885 /* If the thread layer isn't initialized, return. It may just
886 be that the program uses clone, but does not use libthread_db. */
887 if (thread_db
== NULL
|| !thread_db
->all_symbols_looked_up
)
890 /* find_one_thread calls into libthread_db which accesses memory via
891 the current thread. Temporarily switch to a thread we know is
893 scoped_restore_current_thread restore_thread
;
894 switch_to_thread (parent_thr
);
896 if (!find_one_thread (child_ptid
))
897 warning ("Cannot find thread after clone.");