1 /* Thread management interface, for the remote server for GDB.
2 Copyright (C) 2002-2017 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"
25 extern int debug_threads
;
27 #include "gdb_proc_service.h"
28 #include "nat/gdb_thread_db.h"
30 #include "nat/linux-procfs.h"
31 #include "common/scoped_restore.h"
33 #ifndef USE_LIBTHREAD_DB_DIRECTLY
41 /* Structure that identifies the child process for the
42 <proc_service.h> interface. */
43 struct ps_prochandle proc_handle
;
45 /* Connection to the libthread_db library. */
46 td_thragent_t
*thread_agent
;
48 /* If this flag has been set, we've already asked GDB for all
49 symbols we might need; assume symbol cache misses are
51 int all_symbols_looked_up
;
53 #ifndef USE_LIBTHREAD_DB_DIRECTLY
54 /* Handle of the libthread_db from dlopen. */
58 /* Addresses of libthread_db functions. */
59 td_ta_new_ftype
*td_ta_new_p
;
60 td_ta_map_lwp2thr_ftype
*td_ta_map_lwp2thr_p
;
61 td_thr_get_info_ftype
*td_thr_get_info_p
;
62 td_ta_thr_iter_ftype
*td_ta_thr_iter_p
;
63 td_thr_tls_get_addr_ftype
*td_thr_tls_get_addr_p
;
64 td_thr_tlsbase_ftype
*td_thr_tlsbase_p
;
65 td_symbol_list_ftype
*td_symbol_list_p
;
68 static char *libthread_db_search_path
;
70 static int find_one_thread (ptid_t
);
71 static int find_new_threads_callback (const td_thrhandle_t
*th_p
, void *data
);
74 thread_db_err_str (td_err_e err
)
81 return "generic 'call succeeded'";
83 return "generic error";
85 return "no thread to satisfy query";
87 return "no sync handle to satisfy query";
89 return "no LWP to satisfy query";
91 return "invalid process handle";
93 return "invalid thread handle";
95 return "invalid synchronization handle";
97 return "invalid thread agent";
101 return "no event message for getmsg";
103 return "FPU register set not available";
105 return "application not linked with libthread";
107 return "requested event is not supported";
109 return "capability not available";
111 return "debugger service failed";
113 return "operation not applicable to";
115 return "no thread-specific data for this thread";
117 return "malloc failed";
119 return "only part of register set was written/read";
121 return "X register set not available for this thread";
122 #ifdef HAVE_TD_VERSION
124 return "version mismatch between libthread_db and libpthread";
127 xsnprintf (buf
, sizeof (buf
), "unknown thread_db error '%d'", err
);
134 thread_db_state_str (td_thr_state_e state
)
141 return "stopped by debugger";
150 case TD_THR_STOPPED_ASLEEP
:
151 return "stopped by debugger AND blocked";
153 xsnprintf (buf
, sizeof (buf
), "unknown thread_db state %d", state
);
159 /* Get thread info about PTID, accessing memory via the current
163 find_one_thread (ptid_t ptid
)
168 struct lwp_info
*lwp
;
169 struct thread_db
*thread_db
= current_process ()->priv
->thread_db
;
170 int lwpid
= ptid_get_lwp (ptid
);
172 thread_info
*thread
= find_thread_ptid (ptid
);
173 lwp
= get_thread_lwp (thread
);
174 if (lwp
->thread_known
)
177 /* Get information about this thread. */
178 err
= thread_db
->td_ta_map_lwp2thr_p (thread_db
->thread_agent
, lwpid
, &th
);
180 error ("Cannot get thread handle for LWP %d: %s",
181 lwpid
, thread_db_err_str (err
));
183 err
= thread_db
->td_thr_get_info_p (&th
, &ti
);
185 error ("Cannot get thread info for LWP %d: %s",
186 lwpid
, thread_db_err_str (err
));
189 debug_printf ("Found thread %ld (LWP %d)\n",
190 (unsigned long) ti
.ti_tid
, ti
.ti_lid
);
192 if (lwpid
!= ti
.ti_lid
)
194 warning ("PID mismatch! Expected %ld, got %ld",
195 (long) lwpid
, (long) ti
.ti_lid
);
199 /* If the new thread ID is zero, a final thread ID will be available
200 later. Do not enable thread debugging yet. */
204 lwp
->thread_known
= 1;
206 lwp
->thread_handle
= ti
.ti_tid
;
211 /* Attach a thread. Return true on success. */
214 attach_thread (const td_thrhandle_t
*th_p
, td_thrinfo_t
*ti_p
)
216 struct process_info
*proc
= current_process ();
217 int pid
= pid_of (proc
);
218 ptid_t ptid
= ptid_build (pid
, ti_p
->ti_lid
, 0);
219 struct lwp_info
*lwp
;
223 debug_printf ("Attaching to thread %ld (LWP %d)\n",
224 (unsigned long) ti_p
->ti_tid
, ti_p
->ti_lid
);
225 err
= linux_attach_lwp (ptid
);
228 warning ("Could not attach to thread %ld (LWP %d): %s\n",
229 (unsigned long) ti_p
->ti_tid
, ti_p
->ti_lid
,
230 linux_ptrace_attach_fail_reason_string (ptid
, err
));
234 lwp
= find_lwp_pid (ptid
);
235 gdb_assert (lwp
!= NULL
);
236 lwp
->thread_known
= 1;
238 lwp
->thread_handle
= ti_p
->ti_tid
;
243 /* Attach thread if we haven't seen it yet.
244 Increment *COUNTER if we have attached a new thread.
245 Return false on failure. */
248 maybe_attach_thread (const td_thrhandle_t
*th_p
, td_thrinfo_t
*ti_p
,
251 struct lwp_info
*lwp
;
253 lwp
= find_lwp_pid (pid_to_ptid (ti_p
->ti_lid
));
257 if (!attach_thread (th_p
, ti_p
))
267 find_new_threads_callback (const td_thrhandle_t
*th_p
, void *data
)
271 struct thread_db
*thread_db
= current_process ()->priv
->thread_db
;
273 err
= thread_db
->td_thr_get_info_p (th_p
, &ti
);
275 error ("Cannot get thread info: %s", thread_db_err_str (err
));
279 /* A thread with kernel thread ID -1 is either a thread that
280 exited and was joined, or a thread that is being created but
281 hasn't started yet, and that is reusing the tcb/stack of a
282 thread that previously exited and was joined. (glibc marks
283 terminated and joined threads with kernel thread ID -1. See
286 debug_printf ("thread_db: skipping exited and "
287 "joined thread (0x%lx)\n",
288 (unsigned long) ti
.ti_tid
);
292 /* Check for zombies. */
293 if (ti
.ti_state
== TD_THR_UNKNOWN
|| ti
.ti_state
== TD_THR_ZOMBIE
)
296 if (!maybe_attach_thread (th_p
, &ti
, (int *) data
))
298 /* Terminate iteration early: we might be looking at stale data in
299 the inferior. The thread_db_find_new_threads will retry. */
307 thread_db_find_new_threads (void)
310 ptid_t ptid
= current_ptid
;
311 struct thread_db
*thread_db
= current_process ()->priv
->thread_db
;
314 /* This function is only called when we first initialize thread_db.
315 First locate the initial thread. If it is not ready for
316 debugging yet, then stop. */
317 if (find_one_thread (ptid
) == 0)
320 /* Require 4 successive iterations which do not find any new threads.
321 The 4 is a heuristic: there is an inherent race here, and I have
322 seen that 2 iterations in a row are not always sufficient to
323 "capture" all threads. */
324 for (loop
= 0, iteration
= 0; loop
< 4; ++loop
, ++iteration
)
326 int new_thread_count
= 0;
328 /* Iterate over all user-space threads to discover new threads. */
329 err
= thread_db
->td_ta_thr_iter_p (thread_db
->thread_agent
,
330 find_new_threads_callback
,
333 TD_THR_LOWEST_PRIORITY
,
334 TD_SIGNO_MASK
, TD_THR_ANY_USER_FLAGS
);
336 debug_printf ("Found %d threads in iteration %d.\n",
337 new_thread_count
, iteration
);
339 if (new_thread_count
!= 0)
341 /* Found new threads. Restart iteration from beginning. */
346 error ("Cannot find new threads: %s", thread_db_err_str (err
));
349 /* Cache all future symbols that thread_db might request. We can not
350 request symbols at arbitrary states in the remote protocol, only
351 when the client tells us that new symbols are available. So when
352 we load the thread library, make sure to check the entire list. */
355 thread_db_look_up_symbols (void)
357 struct thread_db
*thread_db
= current_process ()->priv
->thread_db
;
358 const char **sym_list
;
361 for (sym_list
= thread_db
->td_symbol_list_p (); *sym_list
; sym_list
++)
362 look_up_one_symbol (*sym_list
, &unused
, 1);
364 /* We're not interested in any other libraries loaded after this
365 point, only in symbols in libpthread.so. */
366 thread_db
->all_symbols_looked_up
= 1;
370 thread_db_look_up_one_symbol (const char *name
, CORE_ADDR
*addrp
)
372 struct thread_db
*thread_db
= current_process ()->priv
->thread_db
;
373 int may_ask_gdb
= !thread_db
->all_symbols_looked_up
;
375 /* If we've passed the call to thread_db_look_up_symbols, then
376 anything not in the cache must not exist; we're not interested
377 in any libraries loaded after that point, only in symbols in
378 libpthread.so. It might not be an appropriate time to look
379 up a symbol, e.g. while we're trying to fetch registers. */
380 return look_up_one_symbol (name
, addrp
, may_ask_gdb
);
384 thread_db_get_tls_address (struct thread_info
*thread
, CORE_ADDR offset
,
385 CORE_ADDR load_module
, CORE_ADDR
*address
)
389 struct lwp_info
*lwp
;
390 struct thread_info
*saved_thread
;
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 saved_thread
= current_thread
;
414 current_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
;
437 current_thread
= saved_thread
;
440 *address
= (CORE_ADDR
) (uintptr_t) addr
;
447 /* See linux-low.h. */
450 thread_db_thread_handle (ptid_t ptid
, gdb_byte
**handle
, int *handle_len
)
452 struct thread_db
*thread_db
;
453 struct lwp_info
*lwp
;
454 thread_info
*thread
= find_thread_ptid (ptid
);
459 thread_db
= get_thread_process (thread
)->priv
->thread_db
;
461 if (thread_db
== NULL
)
464 lwp
= get_thread_lwp (thread
);
466 if (!lwp
->thread_known
&& !find_one_thread (thread
->id
))
469 gdb_assert (lwp
->thread_known
);
471 *handle
= (gdb_byte
*) &lwp
->thread_handle
;
472 *handle_len
= sizeof (lwp
->thread_handle
);
476 #ifdef USE_LIBTHREAD_DB_DIRECTLY
479 thread_db_load_search (void)
482 struct thread_db
*tdb
;
483 struct process_info
*proc
= current_process ();
485 gdb_assert (proc
->priv
->thread_db
== NULL
);
487 tdb
= XCNEW (struct thread_db
);
488 proc
->priv
->thread_db
= tdb
;
490 tdb
->td_ta_new_p
= &td_ta_new
;
492 /* Attempt to open a connection to the thread library. */
493 err
= tdb
->td_ta_new_p (&tdb
->proc_handle
, &tdb
->thread_agent
);
497 debug_printf ("td_ta_new(): %s\n", thread_db_err_str (err
));
499 proc
->priv
->thread_db
= NULL
;
503 tdb
->td_ta_map_lwp2thr_p
= &td_ta_map_lwp2thr
;
504 tdb
->td_thr_get_info_p
= &td_thr_get_info
;
505 tdb
->td_ta_thr_iter_p
= &td_ta_thr_iter
;
506 tdb
->td_symbol_list_p
= &td_symbol_list
;
508 /* These are not essential. */
509 tdb
->td_thr_tls_get_addr_p
= &td_thr_tls_get_addr
;
510 tdb
->td_thr_tlsbase_p
= &td_thr_tlsbase
;
518 try_thread_db_load_1 (void *handle
)
521 struct thread_db
*tdb
;
522 struct process_info
*proc
= current_process ();
524 gdb_assert (proc
->priv
->thread_db
== NULL
);
526 tdb
= XCNEW (struct thread_db
);
527 proc
->priv
->thread_db
= tdb
;
529 tdb
->handle
= handle
;
531 /* Initialize pointers to the dynamic library functions we will use.
532 Essential functions first. */
534 #define CHK(required, a) \
540 debug_printf ("dlsym: %s\n", dlerror ()); \
544 proc->priv->thread_db = NULL; \
551 #define TDB_DLSYM(tdb, func) \
552 tdb->func ## _p = (func ## _ftype *) dlsym (tdb->handle, #func)
554 CHK (1, TDB_DLSYM (tdb
, td_ta_new
));
556 /* Attempt to open a connection to the thread library. */
557 err
= tdb
->td_ta_new_p (&tdb
->proc_handle
, &tdb
->thread_agent
);
561 debug_printf ("td_ta_new(): %s\n", thread_db_err_str (err
));
563 proc
->priv
->thread_db
= NULL
;
567 CHK (1, TDB_DLSYM (tdb
, td_ta_map_lwp2thr
));
568 CHK (1, TDB_DLSYM (tdb
, td_thr_get_info
));
569 CHK (1, TDB_DLSYM (tdb
, td_ta_thr_iter
));
570 CHK (1, TDB_DLSYM (tdb
, td_symbol_list
));
572 /* These are not essential. */
573 CHK (0, TDB_DLSYM (tdb
, td_thr_tls_get_addr
));
574 CHK (0, TDB_DLSYM (tdb
, td_thr_tlsbase
));
584 /* Lookup a library in which given symbol resides.
585 Note: this is looking in the GDBSERVER process, not in the inferior.
586 Returns library name, or NULL. */
589 dladdr_to_soname (const void *addr
)
593 if (dladdr (addr
, &info
) != 0)
594 return info
.dli_fname
;
601 try_thread_db_load (const char *library
)
606 debug_printf ("Trying host libthread_db library: %s.\n",
608 handle
= dlopen (library
, RTLD_NOW
);
612 debug_printf ("dlopen failed: %s.\n", dlerror ());
617 if (debug_threads
&& strchr (library
, '/') == NULL
)
621 td_init
= dlsym (handle
, "td_init");
624 const char *const libpath
= dladdr_to_soname (td_init
);
627 debug_printf ("Host %s resolved to: %s.\n", library
, libpath
);
632 if (try_thread_db_load_1 (handle
))
635 /* This library "refused" to work on current inferior. */
640 /* Handle $sdir in libthread-db-search-path.
641 Look for libthread_db in the system dirs, or wherever a plain
642 dlopen(file_without_path) will look.
643 The result is true for success. */
646 try_thread_db_load_from_sdir (void)
648 return try_thread_db_load (LIBTHREAD_DB_SO
);
651 /* Try to load libthread_db from directory DIR of length DIR_LEN.
652 The result is true for success. */
655 try_thread_db_load_from_dir (const char *dir
, size_t dir_len
)
659 if (dir_len
+ 1 + strlen (LIBTHREAD_DB_SO
) + 1 > sizeof (path
))
661 char *cp
= (char *) xmalloc (dir_len
+ 1);
663 memcpy (cp
, dir
, dir_len
);
665 warning (_("libthread-db-search-path component too long,"
666 " ignored: %s."), cp
);
671 memcpy (path
, dir
, dir_len
);
673 strcpy (path
+ dir_len
+ 1, LIBTHREAD_DB_SO
);
674 return try_thread_db_load (path
);
677 /* Search libthread_db_search_path for libthread_db which "agrees"
678 to work on current inferior.
679 The result is true for success. */
682 thread_db_load_search (void)
684 VEC (char_ptr
) *dir_vec
;
688 if (libthread_db_search_path
== NULL
)
689 libthread_db_search_path
= xstrdup (LIBTHREAD_DB_SEARCH_PATH
);
691 dir_vec
= dirnames_to_char_ptr_vec (libthread_db_search_path
);
693 for (i
= 0; VEC_iterate (char_ptr
, dir_vec
, i
, this_dir
); ++i
)
695 const int pdir_len
= sizeof ("$pdir") - 1;
698 this_dir_len
= strlen (this_dir
);
700 if (strncmp (this_dir
, "$pdir", pdir_len
) == 0
701 && (this_dir
[pdir_len
] == '\0'
702 || this_dir
[pdir_len
] == '/'))
704 /* We don't maintain a list of loaded libraries so we don't know
705 where libpthread lives. We *could* fetch the info, but we don't
706 do that yet. Ignore it. */
708 else if (strcmp (this_dir
, "$sdir") == 0)
710 if (try_thread_db_load_from_sdir ())
718 if (try_thread_db_load_from_dir (this_dir
, this_dir_len
))
726 free_char_ptr_vec (dir_vec
);
728 debug_printf ("thread_db_load_search returning %d\n", rc
);
732 #endif /* USE_LIBTHREAD_DB_DIRECTLY */
735 thread_db_init (void)
737 struct process_info
*proc
= current_process ();
739 /* FIXME drow/2004-10-16: This is the "overall process ID", which
740 GNU/Linux calls tgid, "thread group ID". When we support
741 attaching to threads, the original thread may not be the correct
742 thread. We would have to get the process ID from /proc for NPTL.
744 This isn't the only place in gdbserver that assumes that the first
745 process in the list is the thread group leader. */
747 if (thread_db_load_search ())
749 /* It's best to avoid td_ta_thr_iter if possible. That walks
750 data structures in the inferior's address space that may be
751 corrupted, or, if the target is running, the list may change
752 while we walk it. In the latter case, it's possible that a
753 thread exits just at the exact time that causes GDBserver to
754 get stuck in an infinite loop. As the kernel supports clone
755 events and /proc/PID/task/ exists, then we already know about
756 all threads in the process. When we need info out of
757 thread_db on a given thread (e.g., for TLS), we'll use
758 find_one_thread then. That uses thread_db entry points that
759 do not walk libpthread's thread list, so should be safe, as
760 well as more efficient. */
761 if (!linux_proc_task_list_dir_exists (pid_of (proc
)))
762 thread_db_find_new_threads ();
763 thread_db_look_up_symbols ();
771 switch_to_process (struct process_info
*proc
)
773 int pid
= pid_of (proc
);
775 current_thread
= find_any_thread_of_pid (pid
);
778 /* Disconnect from libthread_db and free resources. */
781 disable_thread_event_reporting (struct process_info
*proc
)
783 struct thread_db
*thread_db
= proc
->priv
->thread_db
;
786 td_err_e (*td_ta_clear_event_p
) (const td_thragent_t
*ta
,
787 td_thr_events_t
*event
);
789 #ifndef USE_LIBTHREAD_DB_DIRECTLY
791 = (td_ta_clear_event_ftype
*) dlsym (thread_db
->handle
,
792 "td_ta_clear_event");
794 td_ta_clear_event_p
= &td_ta_clear_event
;
797 if (td_ta_clear_event_p
!= NULL
)
799 struct thread_info
*saved_thread
= current_thread
;
800 td_thr_events_t events
;
802 switch_to_process (proc
);
804 /* Set the process wide mask saying we aren't interested
805 in any events anymore. */
806 td_event_fillset (&events
);
807 (*td_ta_clear_event_p
) (thread_db
->thread_agent
, &events
);
809 current_thread
= saved_thread
;
815 thread_db_detach (struct process_info
*proc
)
817 struct thread_db
*thread_db
= proc
->priv
->thread_db
;
821 disable_thread_event_reporting (proc
);
825 /* Disconnect from libthread_db and free resources. */
828 thread_db_mourn (struct process_info
*proc
)
830 struct thread_db
*thread_db
= proc
->priv
->thread_db
;
833 td_ta_delete_ftype
*td_ta_delete_p
;
835 #ifndef USE_LIBTHREAD_DB_DIRECTLY
836 td_ta_delete_p
= (td_ta_delete_ftype
*) dlsym (thread_db
->handle
, "td_ta_delete");
838 td_ta_delete_p
= &td_ta_delete
;
841 if (td_ta_delete_p
!= NULL
)
842 (*td_ta_delete_p
) (thread_db
->thread_agent
);
844 #ifndef USE_LIBTHREAD_DB_DIRECTLY
845 dlclose (thread_db
->handle
);
846 #endif /* USE_LIBTHREAD_DB_DIRECTLY */
849 proc
->priv
->thread_db
= NULL
;
853 /* Handle "set libthread-db-search-path" monitor command and return 1.
854 For any other command, return 0. */
857 thread_db_handle_monitor_command (char *mon
)
859 const char *cmd
= "set libthread-db-search-path";
860 size_t cmd_len
= strlen (cmd
);
862 if (strncmp (mon
, cmd
, cmd_len
) == 0
863 && (mon
[cmd_len
] == '\0'
864 || mon
[cmd_len
] == ' '))
866 const char *cp
= mon
+ cmd_len
;
868 if (libthread_db_search_path
!= NULL
)
869 free (libthread_db_search_path
);
871 /* Skip leading space (if any). */
872 while (isspace (*cp
))
876 cp
= LIBTHREAD_DB_SEARCH_PATH
;
877 libthread_db_search_path
= xstrdup (cp
);
879 monitor_output ("libthread-db-search-path set to `");
880 monitor_output (libthread_db_search_path
);
881 monitor_output ("'\n");
885 /* Tell server.c to perform default processing. */
889 /* See linux-low.h. */
892 thread_db_notice_clone (struct thread_info
*parent_thr
, ptid_t child_ptid
)
894 process_info
*parent_proc
= get_thread_process (parent_thr
);
895 struct thread_db
*thread_db
= parent_proc
->priv
->thread_db
;
897 /* If the thread layer isn't initialized, return. It may just
898 be that the program uses clone, but does not use libthread_db. */
899 if (thread_db
== NULL
|| !thread_db
->all_symbols_looked_up
)
902 /* find_one_thread calls into libthread_db which accesses memory via
903 the current thread. Temporarily switch to a thread we know is
905 scoped_restore restore_current_thread
906 = make_scoped_restore (¤t_thread
, parent_thr
);
908 if (!find_one_thread (child_ptid
))
909 warning ("Cannot find thread after clone.\n");