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 thread_info
*inferior
;
169 struct lwp_info
*lwp
;
170 struct thread_db
*thread_db
= current_process ()->priv
->thread_db
;
171 int lwpid
= ptid_get_lwp (ptid
);
173 inferior
= (struct thread_info
*) find_inferior_id (&all_threads
, ptid
);
174 lwp
= get_thread_lwp (inferior
);
175 if (lwp
->thread_known
)
178 /* Get information about this thread. */
179 err
= thread_db
->td_ta_map_lwp2thr_p (thread_db
->thread_agent
, lwpid
, &th
);
181 error ("Cannot get thread handle for LWP %d: %s",
182 lwpid
, thread_db_err_str (err
));
184 err
= thread_db
->td_thr_get_info_p (&th
, &ti
);
186 error ("Cannot get thread info for LWP %d: %s",
187 lwpid
, thread_db_err_str (err
));
190 debug_printf ("Found thread %ld (LWP %d)\n",
191 (unsigned long) ti
.ti_tid
, ti
.ti_lid
);
193 if (lwpid
!= ti
.ti_lid
)
195 warning ("PID mismatch! Expected %ld, got %ld",
196 (long) lwpid
, (long) ti
.ti_lid
);
200 /* If the new thread ID is zero, a final thread ID will be available
201 later. Do not enable thread debugging yet. */
205 lwp
->thread_known
= 1;
207 lwp
->thread_handle
= ti
.ti_tid
;
212 /* Attach a thread. Return true on success. */
215 attach_thread (const td_thrhandle_t
*th_p
, td_thrinfo_t
*ti_p
)
217 struct process_info
*proc
= current_process ();
218 int pid
= pid_of (proc
);
219 ptid_t ptid
= ptid_build (pid
, ti_p
->ti_lid
, 0);
220 struct lwp_info
*lwp
;
224 debug_printf ("Attaching to thread %ld (LWP %d)\n",
225 (unsigned long) ti_p
->ti_tid
, ti_p
->ti_lid
);
226 err
= linux_attach_lwp (ptid
);
229 warning ("Could not attach to thread %ld (LWP %d): %s\n",
230 (unsigned long) ti_p
->ti_tid
, ti_p
->ti_lid
,
231 linux_ptrace_attach_fail_reason_string (ptid
, err
));
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 (pid_to_ptid (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 thread_info
*saved_thread
;
392 struct process_info
*proc
;
393 struct thread_db
*thread_db
;
395 proc
= get_thread_process (thread
);
396 thread_db
= proc
->priv
->thread_db
;
398 /* If the thread layer is not (yet) initialized, fail. */
399 if (thread_db
== NULL
|| !thread_db
->all_symbols_looked_up
)
402 /* If td_thr_tls_get_addr is missing rather do not expect td_thr_tlsbase
404 if (thread_db
->td_thr_tls_get_addr_p
== NULL
405 || (load_module
== 0 && thread_db
->td_thr_tlsbase_p
== NULL
))
408 lwp
= get_thread_lwp (thread
);
409 if (!lwp
->thread_known
)
410 find_one_thread (thread
->id
);
411 if (!lwp
->thread_known
)
414 saved_thread
= current_thread
;
415 current_thread
= thread
;
417 if (load_module
!= 0)
419 /* Note the cast through uintptr_t: this interface only works if
420 a target address fits in a psaddr_t, which is a host pointer.
421 So a 32-bit debugger can not access 64-bit TLS through this. */
422 err
= thread_db
->td_thr_tls_get_addr_p (&lwp
->th
,
423 (psaddr_t
) (uintptr_t) load_module
,
428 /* This code path handles the case of -static -pthread executables:
429 https://sourceware.org/ml/libc-help/2014-03/msg00024.html
430 For older GNU libc r_debug.r_map is NULL. For GNU libc after
431 PR libc/16831 due to GDB PR threads/16954 LOAD_MODULE is also NULL.
432 The constant number 1 depends on GNU __libc_setup_tls
433 initialization of l_tls_modid to 1. */
434 err
= thread_db
->td_thr_tlsbase_p (&lwp
->th
, 1, &addr
);
435 addr
= (char *) addr
+ offset
;
438 current_thread
= saved_thread
;
441 *address
= (CORE_ADDR
) (uintptr_t) addr
;
448 /* See linux-low.h. */
451 thread_db_thread_handle (ptid_t ptid
, gdb_byte
**handle
, int *handle_len
)
453 struct thread_db
*thread_db
;
454 struct lwp_info
*lwp
;
455 struct thread_info
*thread
456 = (struct thread_info
*) find_inferior_id (&all_threads
, ptid
);
461 thread_db
= get_thread_process (thread
)->priv
->thread_db
;
463 if (thread_db
== NULL
)
466 lwp
= get_thread_lwp (thread
);
468 if (!lwp
->thread_known
&& !find_one_thread (thread
->id
))
471 gdb_assert (lwp
->thread_known
);
473 *handle
= (gdb_byte
*) &lwp
->thread_handle
;
474 *handle_len
= sizeof (lwp
->thread_handle
);
478 #ifdef USE_LIBTHREAD_DB_DIRECTLY
481 thread_db_load_search (void)
484 struct thread_db
*tdb
;
485 struct process_info
*proc
= current_process ();
487 gdb_assert (proc
->priv
->thread_db
== NULL
);
489 tdb
= XCNEW (struct thread_db
);
490 proc
->priv
->thread_db
= tdb
;
492 tdb
->td_ta_new_p
= &td_ta_new
;
494 /* Attempt to open a connection to the thread library. */
495 err
= tdb
->td_ta_new_p (&tdb
->proc_handle
, &tdb
->thread_agent
);
499 debug_printf ("td_ta_new(): %s\n", thread_db_err_str (err
));
501 proc
->priv
->thread_db
= NULL
;
505 tdb
->td_ta_map_lwp2thr_p
= &td_ta_map_lwp2thr
;
506 tdb
->td_thr_get_info_p
= &td_thr_get_info
;
507 tdb
->td_ta_thr_iter_p
= &td_ta_thr_iter
;
508 tdb
->td_symbol_list_p
= &td_symbol_list
;
510 /* These are not essential. */
511 tdb
->td_thr_tls_get_addr_p
= &td_thr_tls_get_addr
;
512 tdb
->td_thr_tlsbase_p
= &td_thr_tlsbase
;
520 try_thread_db_load_1 (void *handle
)
523 struct thread_db
*tdb
;
524 struct process_info
*proc
= current_process ();
526 gdb_assert (proc
->priv
->thread_db
== NULL
);
528 tdb
= XCNEW (struct thread_db
);
529 proc
->priv
->thread_db
= tdb
;
531 tdb
->handle
= handle
;
533 /* Initialize pointers to the dynamic library functions we will use.
534 Essential functions first. */
536 #define CHK(required, a) \
542 debug_printf ("dlsym: %s\n", dlerror ()); \
546 proc->priv->thread_db = NULL; \
553 #define TDB_DLSYM(tdb, func) \
554 tdb->func ## _p = (func ## _ftype *) dlsym (tdb->handle, #func)
556 CHK (1, TDB_DLSYM (tdb
, td_ta_new
));
558 /* Attempt to open a connection to the thread library. */
559 err
= tdb
->td_ta_new_p (&tdb
->proc_handle
, &tdb
->thread_agent
);
563 debug_printf ("td_ta_new(): %s\n", thread_db_err_str (err
));
565 proc
->priv
->thread_db
= NULL
;
569 CHK (1, TDB_DLSYM (tdb
, td_ta_map_lwp2thr
));
570 CHK (1, TDB_DLSYM (tdb
, td_thr_get_info
));
571 CHK (1, TDB_DLSYM (tdb
, td_ta_thr_iter
));
572 CHK (1, TDB_DLSYM (tdb
, td_symbol_list
));
574 /* These are not essential. */
575 CHK (0, TDB_DLSYM (tdb
, td_thr_tls_get_addr
));
576 CHK (0, TDB_DLSYM (tdb
, td_thr_tlsbase
));
586 /* Lookup a library in which given symbol resides.
587 Note: this is looking in the GDBSERVER process, not in the inferior.
588 Returns library name, or NULL. */
591 dladdr_to_soname (const void *addr
)
595 if (dladdr (addr
, &info
) != 0)
596 return info
.dli_fname
;
603 try_thread_db_load (const char *library
)
608 debug_printf ("Trying host libthread_db library: %s.\n",
610 handle
= dlopen (library
, RTLD_NOW
);
614 debug_printf ("dlopen failed: %s.\n", dlerror ());
619 if (debug_threads
&& strchr (library
, '/') == NULL
)
623 td_init
= dlsym (handle
, "td_init");
626 const char *const libpath
= dladdr_to_soname (td_init
);
629 debug_printf ("Host %s resolved to: %s.\n", library
, libpath
);
634 if (try_thread_db_load_1 (handle
))
637 /* This library "refused" to work on current inferior. */
642 /* Handle $sdir in libthread-db-search-path.
643 Look for libthread_db in the system dirs, or wherever a plain
644 dlopen(file_without_path) will look.
645 The result is true for success. */
648 try_thread_db_load_from_sdir (void)
650 return try_thread_db_load (LIBTHREAD_DB_SO
);
653 /* Try to load libthread_db from directory DIR of length DIR_LEN.
654 The result is true for success. */
657 try_thread_db_load_from_dir (const char *dir
, size_t dir_len
)
661 if (dir_len
+ 1 + strlen (LIBTHREAD_DB_SO
) + 1 > sizeof (path
))
663 char *cp
= (char *) xmalloc (dir_len
+ 1);
665 memcpy (cp
, dir
, dir_len
);
667 warning (_("libthread-db-search-path component too long,"
668 " ignored: %s."), cp
);
673 memcpy (path
, dir
, dir_len
);
675 strcpy (path
+ dir_len
+ 1, LIBTHREAD_DB_SO
);
676 return try_thread_db_load (path
);
679 /* Search libthread_db_search_path for libthread_db which "agrees"
680 to work on current inferior.
681 The result is true for success. */
684 thread_db_load_search (void)
686 VEC (char_ptr
) *dir_vec
;
690 if (libthread_db_search_path
== NULL
)
691 libthread_db_search_path
= xstrdup (LIBTHREAD_DB_SEARCH_PATH
);
693 dir_vec
= dirnames_to_char_ptr_vec (libthread_db_search_path
);
695 for (i
= 0; VEC_iterate (char_ptr
, dir_vec
, i
, this_dir
); ++i
)
697 const int pdir_len
= sizeof ("$pdir") - 1;
700 this_dir_len
= strlen (this_dir
);
702 if (strncmp (this_dir
, "$pdir", pdir_len
) == 0
703 && (this_dir
[pdir_len
] == '\0'
704 || this_dir
[pdir_len
] == '/'))
706 /* We don't maintain a list of loaded libraries so we don't know
707 where libpthread lives. We *could* fetch the info, but we don't
708 do that yet. Ignore it. */
710 else if (strcmp (this_dir
, "$sdir") == 0)
712 if (try_thread_db_load_from_sdir ())
720 if (try_thread_db_load_from_dir (this_dir
, this_dir_len
))
728 free_char_ptr_vec (dir_vec
);
730 debug_printf ("thread_db_load_search returning %d\n", rc
);
734 #endif /* USE_LIBTHREAD_DB_DIRECTLY */
737 thread_db_init (void)
739 struct process_info
*proc
= current_process ();
741 /* FIXME drow/2004-10-16: This is the "overall process ID", which
742 GNU/Linux calls tgid, "thread group ID". When we support
743 attaching to threads, the original thread may not be the correct
744 thread. We would have to get the process ID from /proc for NPTL.
746 This isn't the only place in gdbserver that assumes that the first
747 process in the list is the thread group leader. */
749 if (thread_db_load_search ())
751 /* It's best to avoid td_ta_thr_iter if possible. That walks
752 data structures in the inferior's address space that may be
753 corrupted, or, if the target is running, the list may change
754 while we walk it. In the latter case, it's possible that a
755 thread exits just at the exact time that causes GDBserver to
756 get stuck in an infinite loop. As the kernel supports clone
757 events and /proc/PID/task/ exists, then we already know about
758 all threads in the process. When we need info out of
759 thread_db on a given thread (e.g., for TLS), we'll use
760 find_one_thread then. That uses thread_db entry points that
761 do not walk libpthread's thread list, so should be safe, as
762 well as more efficient. */
763 if (!linux_proc_task_list_dir_exists (pid_of (proc
)))
764 thread_db_find_new_threads ();
765 thread_db_look_up_symbols ();
773 switch_to_process (struct process_info
*proc
)
775 int pid
= pid_of (proc
);
777 current_thread
= find_any_thread_of_pid (pid
);
780 /* Disconnect from libthread_db and free resources. */
783 disable_thread_event_reporting (struct process_info
*proc
)
785 struct thread_db
*thread_db
= proc
->priv
->thread_db
;
788 td_err_e (*td_ta_clear_event_p
) (const td_thragent_t
*ta
,
789 td_thr_events_t
*event
);
791 #ifndef USE_LIBTHREAD_DB_DIRECTLY
793 = (td_ta_clear_event_ftype
*) dlsym (thread_db
->handle
,
794 "td_ta_clear_event");
796 td_ta_clear_event_p
= &td_ta_clear_event
;
799 if (td_ta_clear_event_p
!= NULL
)
801 struct thread_info
*saved_thread
= current_thread
;
802 td_thr_events_t events
;
804 switch_to_process (proc
);
806 /* Set the process wide mask saying we aren't interested
807 in any events anymore. */
808 td_event_fillset (&events
);
809 (*td_ta_clear_event_p
) (thread_db
->thread_agent
, &events
);
811 current_thread
= saved_thread
;
817 thread_db_detach (struct process_info
*proc
)
819 struct thread_db
*thread_db
= proc
->priv
->thread_db
;
823 disable_thread_event_reporting (proc
);
827 /* Disconnect from libthread_db and free resources. */
830 thread_db_mourn (struct process_info
*proc
)
832 struct thread_db
*thread_db
= proc
->priv
->thread_db
;
835 td_ta_delete_ftype
*td_ta_delete_p
;
837 #ifndef USE_LIBTHREAD_DB_DIRECTLY
838 td_ta_delete_p
= (td_ta_delete_ftype
*) dlsym (thread_db
->handle
, "td_ta_delete");
840 td_ta_delete_p
= &td_ta_delete
;
843 if (td_ta_delete_p
!= NULL
)
844 (*td_ta_delete_p
) (thread_db
->thread_agent
);
846 #ifndef USE_LIBTHREAD_DB_DIRECTLY
847 dlclose (thread_db
->handle
);
848 #endif /* USE_LIBTHREAD_DB_DIRECTLY */
851 proc
->priv
->thread_db
= NULL
;
855 /* Handle "set libthread-db-search-path" monitor command and return 1.
856 For any other command, return 0. */
859 thread_db_handle_monitor_command (char *mon
)
861 const char *cmd
= "set libthread-db-search-path";
862 size_t cmd_len
= strlen (cmd
);
864 if (strncmp (mon
, cmd
, cmd_len
) == 0
865 && (mon
[cmd_len
] == '\0'
866 || mon
[cmd_len
] == ' '))
868 const char *cp
= mon
+ cmd_len
;
870 if (libthread_db_search_path
!= NULL
)
871 free (libthread_db_search_path
);
873 /* Skip leading space (if any). */
874 while (isspace (*cp
))
878 cp
= LIBTHREAD_DB_SEARCH_PATH
;
879 libthread_db_search_path
= xstrdup (cp
);
881 monitor_output ("libthread-db-search-path set to `");
882 monitor_output (libthread_db_search_path
);
883 monitor_output ("'\n");
887 /* Tell server.c to perform default processing. */
891 /* See linux-low.h. */
894 thread_db_notice_clone (struct thread_info
*parent_thr
, ptid_t child_ptid
)
896 process_info
*parent_proc
= get_thread_process (parent_thr
);
897 struct thread_db
*thread_db
= parent_proc
->priv
->thread_db
;
899 /* If the thread layer isn't initialized, return. It may just
900 be that the program uses clone, but does not use libthread_db. */
901 if (thread_db
== NULL
|| !thread_db
->all_symbols_looked_up
)
904 /* find_one_thread calls into libthread_db which accesses memory via
905 the current thread. Temporarily switch to a thread we know is
907 scoped_restore restore_current_thread
908 = make_scoped_restore (¤t_thread
, parent_thr
);
910 if (!find_one_thread (child_ptid
))
911 warning ("Cannot find thread after clone.\n");