1 /* libthread_db assisted debugging support, generic parts.
3 Copyright (C) 1999, 2000, 2001, 2003, 2004, 2005, 2006, 2007, 2008
4 Free Software Foundation, Inc.
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 "gdb_assert.h"
25 #include "gdb_proc_service.h"
26 #include "gdb_thread_db.h"
29 #include "exceptions.h"
30 #include "gdbthread.h"
36 #include "solib-svr4.h"
39 #include "linux-nat.h"
43 #ifdef HAVE_GNU_LIBC_VERSION_H
44 #include <gnu/libc-version.h>
47 #ifndef LIBTHREAD_DB_SO
48 #define LIBTHREAD_DB_SO "libthread_db.so.1"
51 /* GNU/Linux libthread_db support.
53 libthread_db is a library, provided along with libpthread.so, which
54 exposes the internals of the thread library to a debugger. It
55 allows GDB to find existing threads, new threads as they are
56 created, thread IDs (usually, the result of pthread_self), and
57 thread-local variables.
59 The libthread_db interface originates on Solaris, where it is
60 both more powerful and more complicated. This implementation
61 only works for LinuxThreads and NPTL, the two glibc threading
62 libraries. It assumes that each thread is permanently assigned
63 to a single light-weight process (LWP).
65 libthread_db-specific information is stored in the "private" field
66 of struct thread_info. When the field is NULL we do not yet have
67 information about the new thread; this could be temporary (created,
68 but the thread library's data structures do not reflect it yet)
69 or permanent (created using clone instead of pthread_create).
71 Process IDs managed by linux-thread-db.c match those used by
72 linux-nat.c: a common PID for all processes, an LWP ID for each
73 thread, and no TID. We save the TID in private. Keeping it out
74 of the ptid_t prevents thread IDs changing when libpthread is
75 loaded or unloaded. */
77 /* If we're running on GNU/Linux, we must explicitly attach to any new
80 /* This module's target vector. */
81 static struct target_ops thread_db_ops
;
83 /* The target vector that we call for things this module can't handle. */
84 static struct target_ops
*target_beneath
;
86 /* Non-zero if we're using this module's target vector. */
87 static int using_thread_db
;
89 /* Non-zero if we have determined the signals used by the threads
91 static int thread_signals
;
92 static sigset_t thread_stop_set
;
93 static sigset_t thread_print_set
;
95 /* Structure that identifies the child process for the
96 <proc_service.h> interface. */
97 static struct ps_prochandle proc_handle
;
99 /* Connection to the libthread_db library. */
100 static td_thragent_t
*thread_agent
;
102 /* Pointers to the libthread_db functions. */
104 static td_err_e (*td_init_p
) (void);
106 static td_err_e (*td_ta_new_p
) (struct ps_prochandle
* ps
,
108 static td_err_e (*td_ta_map_id2thr_p
) (const td_thragent_t
*ta
, thread_t pt
,
109 td_thrhandle_t
*__th
);
110 static td_err_e (*td_ta_map_lwp2thr_p
) (const td_thragent_t
*ta
,
111 lwpid_t lwpid
, td_thrhandle_t
*th
);
112 static td_err_e (*td_ta_thr_iter_p
) (const td_thragent_t
*ta
,
113 td_thr_iter_f
*callback
, void *cbdata_p
,
114 td_thr_state_e state
, int ti_pri
,
115 sigset_t
*ti_sigmask_p
,
116 unsigned int ti_user_flags
);
117 static td_err_e (*td_ta_event_addr_p
) (const td_thragent_t
*ta
,
118 td_event_e event
, td_notify_t
*ptr
);
119 static td_err_e (*td_ta_set_event_p
) (const td_thragent_t
*ta
,
120 td_thr_events_t
*event
);
121 static td_err_e (*td_ta_event_getmsg_p
) (const td_thragent_t
*ta
,
122 td_event_msg_t
*msg
);
124 static td_err_e (*td_thr_validate_p
) (const td_thrhandle_t
*th
);
125 static td_err_e (*td_thr_get_info_p
) (const td_thrhandle_t
*th
,
126 td_thrinfo_t
*infop
);
127 static td_err_e (*td_thr_event_enable_p
) (const td_thrhandle_t
*th
,
130 static td_err_e (*td_thr_tls_get_addr_p
) (const td_thrhandle_t
*th
,
132 size_t offset
, void **address
);
134 /* Location of the thread creation event breakpoint. The code at this
135 location in the child process will be called by the pthread library
136 whenever a new thread is created. By setting a special breakpoint
137 at this location, GDB can detect when a new thread is created. We
138 obtain this location via the td_ta_event_addr call. */
139 static CORE_ADDR td_create_bp_addr
;
141 /* Location of the thread death event breakpoint. */
142 static CORE_ADDR td_death_bp_addr
;
144 /* Prototypes for local functions. */
145 static void thread_db_find_new_threads (void);
146 static void attach_thread (ptid_t ptid
, const td_thrhandle_t
*th_p
,
147 const td_thrinfo_t
*ti_p
);
148 static void detach_thread (ptid_t ptid
);
151 /* Use "struct private_thread_info" to cache thread state. This is
152 a substantial optimization. */
154 struct private_thread_info
156 /* Flag set when we see a TD_DEATH event for this thread. */
157 unsigned int dying
:1;
159 /* Cached thread state. */
166 thread_db_err_str (td_err_e err
)
173 return "generic 'call succeeded'";
175 return "generic error";
177 return "no thread to satisfy query";
179 return "no sync handle to satisfy query";
181 return "no LWP to satisfy query";
183 return "invalid process handle";
185 return "invalid thread handle";
187 return "invalid synchronization handle";
189 return "invalid thread agent";
191 return "invalid key";
193 return "no event message for getmsg";
195 return "FPU register set not available";
197 return "application not linked with libthread";
199 return "requested event is not supported";
201 return "capability not available";
203 return "debugger service failed";
205 return "operation not applicable to";
207 return "no thread-specific data for this thread";
209 return "malloc failed";
211 return "only part of register set was written/read";
213 return "X register set not available for this thread";
214 #ifdef THREAD_DB_HAS_TD_NOTALLOC
216 return "thread has not yet allocated TLS for given module";
218 #ifdef THREAD_DB_HAS_TD_VERSION
220 return "versions of libpthread and libthread_db do not match";
222 #ifdef THREAD_DB_HAS_TD_NOTLS
224 return "there is no TLS segment in the given module";
227 snprintf (buf
, sizeof (buf
), "unknown thread_db error '%d'", err
);
232 /* Return 1 if any threads have been registered. There may be none if
233 the threading library is not fully initialized yet. */
236 have_threads_callback (struct thread_info
*thread
, void *dummy
)
244 return iterate_over_threads (have_threads_callback
, NULL
) != NULL
;
247 /* A callback function for td_ta_thr_iter, which we use to map all
250 THP is a handle to the current thread; if INFOP is not NULL, the
251 struct thread_info associated with this thread is returned in
254 If the thread is a zombie, TD_THR_ZOMBIE is returned. Otherwise,
255 zero is returned to indicate success. */
258 thread_get_info_callback (const td_thrhandle_t
*thp
, void *infop
)
262 struct thread_info
*thread_info
;
265 err
= td_thr_get_info_p (thp
, &ti
);
267 error (_("thread_get_info_callback: cannot get thread info: %s"),
268 thread_db_err_str (err
));
270 /* Fill the cache. */
271 thread_ptid
= ptid_build (GET_PID (inferior_ptid
), ti
.ti_lid
, 0);
272 thread_info
= find_thread_pid (thread_ptid
);
274 /* In the case of a zombie thread, don't continue. We don't want to
275 attach to it thinking it is a new thread. */
276 if (ti
.ti_state
== TD_THR_UNKNOWN
|| ti
.ti_state
== TD_THR_ZOMBIE
)
279 *(struct thread_info
**) infop
= thread_info
;
280 return TD_THR_ZOMBIE
;
283 if (thread_info
== NULL
)
285 /* New thread. Attach to it now (why wait?). */
286 attach_thread (thread_ptid
, thp
, &ti
);
287 thread_info
= find_thread_pid (thread_ptid
);
288 gdb_assert (thread_info
!= NULL
);
292 *(struct thread_info
**) infop
= thread_info
;
297 /* Convert between user-level thread ids and LWP ids. */
300 thread_from_lwp (ptid_t ptid
)
304 struct thread_info
*thread_info
;
307 /* This ptid comes from linux-nat.c, which should always fill in the
309 gdb_assert (GET_LWP (ptid
) != 0);
311 err
= td_ta_map_lwp2thr_p (thread_agent
, GET_LWP (ptid
), &th
);
313 error (_("Cannot find user-level thread for LWP %ld: %s"),
314 GET_LWP (ptid
), thread_db_err_str (err
));
318 /* Fetch the thread info. If we get back TD_THR_ZOMBIE, then the
319 event thread has already died. If another gdb interface has called
320 thread_alive() previously, the thread won't be found on the thread list
321 anymore. In that case, we don't want to process this ptid anymore
322 to avoid the possibility of later treating it as a newly
323 discovered thread id that we should add to the list. Thus,
324 we return a -1 ptid which is also how the thread list marks a
326 if (thread_get_info_callback (&th
, &thread_info
) == TD_THR_ZOMBIE
327 && thread_info
== NULL
)
328 return pid_to_ptid (-1);
330 gdb_assert (ptid_get_tid (ptid
) == 0);
336 thread_db_init (struct target_ops
*target
)
338 target_beneath
= target
;
342 verbose_dlsym (void *handle
, const char *name
)
344 void *sym
= dlsym (handle
, name
);
346 warning (_("Symbol \"%s\" not found in libthread_db: %s"), name
, dlerror ());
351 thread_db_load (void)
356 handle
= dlopen (LIBTHREAD_DB_SO
, RTLD_NOW
);
359 fprintf_filtered (gdb_stderr
, "\n\ndlopen failed on '%s' - %s\n",
360 LIBTHREAD_DB_SO
, dlerror ());
361 fprintf_filtered (gdb_stderr
,
362 "GDB will not be able to debug pthreads.\n\n");
366 /* Initialize pointers to the dynamic library functions we will use.
367 Essential functions first. */
369 td_init_p
= verbose_dlsym (handle
, "td_init");
370 if (td_init_p
== NULL
)
373 td_ta_new_p
= verbose_dlsym (handle
, "td_ta_new");
374 if (td_ta_new_p
== NULL
)
377 td_ta_map_id2thr_p
= verbose_dlsym (handle
, "td_ta_map_id2thr");
378 if (td_ta_map_id2thr_p
== NULL
)
381 td_ta_map_lwp2thr_p
= verbose_dlsym (handle
, "td_ta_map_lwp2thr");
382 if (td_ta_map_lwp2thr_p
== NULL
)
385 td_ta_thr_iter_p
= verbose_dlsym (handle
, "td_ta_thr_iter");
386 if (td_ta_thr_iter_p
== NULL
)
389 td_thr_validate_p
= verbose_dlsym (handle
, "td_thr_validate");
390 if (td_thr_validate_p
== NULL
)
393 td_thr_get_info_p
= verbose_dlsym (handle
, "td_thr_get_info");
394 if (td_thr_get_info_p
== NULL
)
397 /* Initialize the library. */
401 warning (_("Cannot initialize libthread_db: %s"), thread_db_err_str (err
));
405 /* These are not essential. */
406 td_ta_event_addr_p
= dlsym (handle
, "td_ta_event_addr");
407 td_ta_set_event_p
= dlsym (handle
, "td_ta_set_event");
408 td_ta_event_getmsg_p
= dlsym (handle
, "td_ta_event_getmsg");
409 td_thr_event_enable_p
= dlsym (handle
, "td_thr_event_enable");
410 td_thr_tls_get_addr_p
= dlsym (handle
, "td_thr_tls_get_addr");
416 enable_thread_event (td_thragent_t
*thread_agent
, int event
, CORE_ADDR
*bp
)
421 /* Get the breakpoint address for thread EVENT. */
422 err
= td_ta_event_addr_p (thread_agent
, event
, ¬ify
);
426 /* Set up the breakpoint. */
427 gdb_assert (exec_bfd
);
428 (*bp
) = (gdbarch_convert_from_func_ptr_addr
430 /* Do proper sign extension for the target. */
431 (bfd_get_sign_extend_vma (exec_bfd
) > 0
432 ? (CORE_ADDR
) (intptr_t) notify
.u
.bptaddr
433 : (CORE_ADDR
) (uintptr_t) notify
.u
.bptaddr
),
435 create_thread_event_breakpoint ((*bp
));
441 enable_thread_event_reporting (void)
443 td_thr_events_t events
;
446 #ifdef HAVE_GNU_LIBC_VERSION_H
447 const char *libc_version
;
448 int libc_major
, libc_minor
;
451 /* We cannot use the thread event reporting facility if these
452 functions aren't available. */
453 if (td_ta_event_addr_p
== NULL
|| td_ta_set_event_p
== NULL
454 || td_ta_event_getmsg_p
== NULL
|| td_thr_event_enable_p
== NULL
)
457 /* Set the process wide mask saying which events we're interested in. */
458 td_event_emptyset (&events
);
459 td_event_addset (&events
, TD_CREATE
);
461 #ifdef HAVE_GNU_LIBC_VERSION_H
462 /* The event reporting facility is broken for TD_DEATH events in
463 glibc 2.1.3, so don't enable it if we have glibc but a lower
465 libc_version
= gnu_get_libc_version ();
466 if (sscanf (libc_version
, "%d.%d", &libc_major
, &libc_minor
) == 2
467 && (libc_major
> 2 || (libc_major
== 2 && libc_minor
> 1)))
469 td_event_addset (&events
, TD_DEATH
);
471 err
= td_ta_set_event_p (thread_agent
, &events
);
474 warning (_("Unable to set global thread event mask: %s"),
475 thread_db_err_str (err
));
479 /* Delete previous thread event breakpoints, if any. */
480 remove_thread_event_breakpoints ();
481 td_create_bp_addr
= 0;
482 td_death_bp_addr
= 0;
484 /* Set up the thread creation event. */
485 err
= enable_thread_event (thread_agent
, TD_CREATE
, &td_create_bp_addr
);
488 warning (_("Unable to get location for thread creation breakpoint: %s"),
489 thread_db_err_str (err
));
493 /* Set up the thread death event. */
494 err
= enable_thread_event (thread_agent
, TD_DEATH
, &td_death_bp_addr
);
497 warning (_("Unable to get location for thread death breakpoint: %s"),
498 thread_db_err_str (err
));
504 disable_thread_event_reporting (void)
506 td_thr_events_t events
;
508 /* Set the process wide mask saying we aren't interested in any
510 td_event_emptyset (&events
);
511 td_ta_set_event_p (thread_agent
, &events
);
513 /* Delete thread event breakpoints, if any. */
514 remove_thread_event_breakpoints ();
515 td_create_bp_addr
= 0;
516 td_death_bp_addr
= 0;
520 check_thread_signals (void)
522 #ifdef GET_THREAD_SIGNALS
528 GET_THREAD_SIGNALS (&mask
);
529 sigemptyset (&thread_stop_set
);
530 sigemptyset (&thread_print_set
);
532 for (i
= 1; i
< NSIG
; i
++)
534 if (sigismember (&mask
, i
))
536 if (signal_stop_update (target_signal_from_host (i
), 0))
537 sigaddset (&thread_stop_set
, i
);
538 if (signal_print_update (target_signal_from_host (i
), 0))
539 sigaddset (&thread_print_set
, i
);
547 /* Check whether thread_db is usable. This function is called when
548 an inferior is created (or otherwise acquired, e.g. attached to)
549 and when new shared libraries are loaded into a running process. */
552 check_for_thread_db (void)
555 static int already_loaded
;
557 /* Do nothing if we couldn't load libthread_db.so.1. */
558 if (td_ta_new_p
== NULL
)
561 /* First time through, report that libthread_db was successfuly
562 loaded. Can't print this in in thread_db_load as, at that stage,
563 the interpreter and it's console haven't started. */
568 const char *library
= NULL
;
569 if (dladdr ((*td_ta_new_p
), &info
) != 0)
570 library
= info
.dli_fname
;
575 /* Paranoid - don't let a NULL path slip through. */
576 library
= LIBTHREAD_DB_SO
;
579 printf_unfiltered (_("Using host libthread_db library \"%s\".\n"),
585 /* Nothing to do. The thread library was already detected and the
586 target vector was already activated. */
589 /* Don't attempt to use thread_db on targets which can not run
590 (executables not running yet, core files) for now. */
591 if (!target_has_execution
)
594 /* Don't attempt to use thread_db for remote targets. */
595 if (!target_can_run (¤t_target
))
598 /* Initialize the structure that identifies the child process. */
599 proc_handle
.pid
= GET_PID (inferior_ptid
);
601 /* Now attempt to open a connection to the thread library. */
602 err
= td_ta_new_p (&proc_handle
, &thread_agent
);
606 /* No thread library was detected. */
610 printf_unfiltered (_("[Thread debugging using libthread_db enabled]\n"));
612 /* The thread library was detected. Activate the thread_db target. */
613 push_target (&thread_db_ops
);
616 enable_thread_event_reporting ();
617 thread_db_find_new_threads ();
621 warning (_("Cannot initialize thread debugging library: %s"),
622 thread_db_err_str (err
));
628 thread_db_new_objfile (struct objfile
*objfile
)
631 check_for_thread_db ();
634 /* Attach to a new thread. This function is called when we receive a
635 TD_CREATE event or when we iterate over all threads and find one
636 that wasn't already in our list. */
639 attach_thread (ptid_t ptid
, const td_thrhandle_t
*th_p
,
640 const td_thrinfo_t
*ti_p
)
642 struct private_thread_info
*private;
643 struct thread_info
*tp
= NULL
;
646 /* If we're being called after a TD_CREATE event, we may already
647 know about this thread. There are two ways this can happen. We
648 may have iterated over all threads between the thread creation
649 and the TD_CREATE event, for instance when the user has issued
650 the `info threads' command before the SIGTRAP for hitting the
651 thread creation breakpoint was reported. Alternatively, the
652 thread may have exited and a new one been created with the same
653 thread ID. In the first case we don't need to do anything; in
654 the second case we should discard information about the dead
655 thread and attach to the new one. */
656 if (in_thread_list (ptid
))
658 tp
= find_thread_pid (ptid
);
659 gdb_assert (tp
!= NULL
);
661 /* If tp->private is NULL, then GDB is already attached to this
662 thread, but we do not know anything about it. We can learn
663 about it here. This can only happen if we have some other
664 way besides libthread_db to notice new threads (i.e.
665 PTRACE_EVENT_CLONE); assume the same mechanism notices thread
666 exit, so this can not be a stale thread recreated with the
668 if (tp
->private != NULL
)
670 if (!tp
->private->dying
)
673 delete_thread (ptid
);
678 check_thread_signals ();
680 if (ti_p
->ti_state
== TD_THR_UNKNOWN
|| ti_p
->ti_state
== TD_THR_ZOMBIE
)
681 return; /* A zombie thread -- do not attach. */
683 /* Under GNU/Linux, we have to attach to each and every thread. */
685 && lin_lwp_attach_lwp (BUILD_LWP (ti_p
->ti_lid
, GET_PID (ptid
))) < 0)
688 /* Construct the thread's private data. */
689 private = xmalloc (sizeof (struct private_thread_info
));
690 memset (private, 0, sizeof (struct private_thread_info
));
692 /* A thread ID of zero may mean the thread library has not initialized
693 yet. But we shouldn't even get here if that's the case. FIXME:
694 if we change GDB to always have at least one thread in the thread
695 list this will have to go somewhere else; maybe private == NULL
696 until the thread_db target claims it. */
697 gdb_assert (ti_p
->ti_tid
!= 0);
699 private->tid
= ti_p
->ti_tid
;
701 /* Add the thread to GDB's thread list. */
703 tp
= add_thread_with_info (ptid
, private);
705 tp
->private = private;
707 /* Enable thread event reporting for this thread. */
708 err
= td_thr_event_enable_p (th_p
, 1);
710 error (_("Cannot enable thread event reporting for %s: %s"),
711 target_pid_to_str (ptid
), thread_db_err_str (err
));
715 detach_thread (ptid_t ptid
)
717 struct thread_info
*thread_info
;
719 /* Don't delete the thread now, because it still reports as active
720 until it has executed a few instructions after the event
721 breakpoint - if we deleted it now, "info threads" would cause us
722 to re-attach to it. Just mark it as having had a TD_DEATH
723 event. This means that we won't delete it from our thread list
724 until we notice that it's dead (via prune_threads), or until
725 something re-uses its thread ID. We'll report the thread exit
726 when the underlying LWP dies. */
727 thread_info
= find_thread_pid (ptid
);
728 gdb_assert (thread_info
!= NULL
&& thread_info
->private != NULL
);
729 thread_info
->private->dying
= 1;
733 thread_db_detach (char *args
, int from_tty
)
735 disable_thread_event_reporting ();
737 target_beneath
->to_detach (args
, from_tty
);
739 /* Should this be done by detach_command? */
740 target_mourn_inferior ();
743 /* Check if PID is currently stopped at the location of a thread event
744 breakpoint location. If it is, read the event message and act upon
748 check_event (ptid_t ptid
)
756 /* Bail out early if we're not at a thread event breakpoint. */
757 stop_pc
= read_pc_pid (ptid
) - gdbarch_decr_pc_after_break (current_gdbarch
);
758 if (stop_pc
!= td_create_bp_addr
&& stop_pc
!= td_death_bp_addr
)
761 /* If we are at a create breakpoint, we do not know what new lwp
762 was created and cannot specifically locate the event message for it.
763 We have to call td_ta_event_getmsg() to get
764 the latest message. Since we have no way of correlating whether
765 the event message we get back corresponds to our breakpoint, we must
766 loop and read all event messages, processing them appropriately.
767 This guarantees we will process the correct message before continuing
770 Currently, death events are not enabled. If they are enabled,
771 the death event can use the td_thr_event_getmsg() interface to
772 get the message specifically for that lwp and avoid looping
779 err
= td_ta_event_getmsg_p (thread_agent
, &msg
);
785 error (_("Cannot get thread event message: %s"),
786 thread_db_err_str (err
));
789 err
= td_thr_get_info_p (msg
.th_p
, &ti
);
791 error (_("Cannot get thread info: %s"), thread_db_err_str (err
));
793 ptid
= ptid_build (GET_PID (ptid
), ti
.ti_lid
, 0);
798 /* Call attach_thread whether or not we already know about a
799 thread with this thread ID. */
800 attach_thread (ptid
, msg
.th_p
, &ti
);
806 if (!in_thread_list (ptid
))
807 error (_("Spurious thread death event."));
809 detach_thread (ptid
);
814 error (_("Spurious thread event."));
821 thread_db_wait (ptid_t ptid
, struct target_waitstatus
*ourstatus
)
823 extern ptid_t trap_ptid
;
825 ptid
= target_beneath
->to_wait (ptid
, ourstatus
);
827 if (ourstatus
->kind
== TARGET_WAITKIND_IGNORE
)
830 if (ourstatus
->kind
== TARGET_WAITKIND_EXITED
831 || ourstatus
->kind
== TARGET_WAITKIND_SIGNALLED
)
832 return pid_to_ptid (-1);
834 if (ourstatus
->kind
== TARGET_WAITKIND_EXECD
)
836 remove_thread_event_breakpoints ();
837 unpush_target (&thread_db_ops
);
840 return pid_to_ptid (GET_PID (ptid
));
843 /* If we do not know about the main thread yet, this would be a good time to
845 if (ourstatus
->kind
== TARGET_WAITKIND_STOPPED
&& !have_threads ())
846 thread_db_find_new_threads ();
848 if (ourstatus
->kind
== TARGET_WAITKIND_STOPPED
849 && ourstatus
->value
.sig
== TARGET_SIGNAL_TRAP
)
850 /* Check for a thread event. */
855 /* Change ptids back into the higher level PID + TID format. If
856 the thread is dead and no longer on the thread list, we will
857 get back a dead ptid. This can occur if the thread death
858 event gets postponed by other simultaneous events. In such a
859 case, we want to just ignore the event and continue on. */
861 if (!ptid_equal (trap_ptid
, null_ptid
))
862 trap_ptid
= thread_from_lwp (trap_ptid
);
864 ptid
= thread_from_lwp (ptid
);
865 if (GET_PID (ptid
) == -1)
866 ourstatus
->kind
= TARGET_WAITKIND_SPURIOUS
;
873 thread_db_mourn_inferior (void)
875 /* Forget about the child's process ID. We shouldn't need it
879 target_beneath
->to_mourn_inferior ();
881 /* Delete the old thread event breakpoints. Do this after mourning
882 the inferior, so that we don't try to uninsert them. */
883 remove_thread_event_breakpoints ();
885 /* Detach thread_db target ops. */
886 unpush_target (&thread_db_ops
);
891 thread_db_can_async_p (void)
893 return target_beneath
->to_can_async_p ();
897 thread_db_is_async_p (void)
899 return target_beneath
->to_is_async_p ();
903 thread_db_async (void (*callback
) (enum inferior_event_type event_type
,
904 void *context
), void *context
)
906 return target_beneath
->to_async (callback
, context
);
910 thread_db_async_mask (int mask
)
912 return target_beneath
->to_async_mask (mask
);
916 find_new_threads_callback (const td_thrhandle_t
*th_p
, void *data
)
921 struct thread_info
*tp
;
923 err
= td_thr_get_info_p (th_p
, &ti
);
925 error (_("find_new_threads_callback: cannot get thread info: %s"),
926 thread_db_err_str (err
));
928 if (ti
.ti_state
== TD_THR_UNKNOWN
|| ti
.ti_state
== TD_THR_ZOMBIE
)
929 return 0; /* A zombie -- ignore. */
931 ptid
= ptid_build (GET_PID (inferior_ptid
), ti
.ti_lid
, 0);
935 /* A thread ID of zero means that this is the main thread, but
936 glibc has not yet initialized thread-local storage and the
937 pthread library. We do not know what the thread's TID will
938 be yet. Just enable event reporting and otherwise ignore
941 err
= td_thr_event_enable_p (th_p
, 1);
943 error (_("Cannot enable thread event reporting for %s: %s"),
944 target_pid_to_str (ptid
), thread_db_err_str (err
));
949 tp
= find_thread_pid (ptid
);
950 if (tp
== NULL
|| tp
->private == NULL
)
951 attach_thread (ptid
, th_p
, &ti
);
957 thread_db_find_new_threads (void)
961 /* Iterate over all user-space threads to discover new threads. */
962 err
= td_ta_thr_iter_p (thread_agent
, find_new_threads_callback
, NULL
,
963 TD_THR_ANY_STATE
, TD_THR_LOWEST_PRIORITY
,
964 TD_SIGNO_MASK
, TD_THR_ANY_USER_FLAGS
);
966 error (_("Cannot find new threads: %s"), thread_db_err_str (err
));
970 thread_db_pid_to_str (ptid_t ptid
)
972 struct thread_info
*thread_info
= find_thread_pid (ptid
);
974 if (thread_info
!= NULL
&& thread_info
->private != NULL
)
979 tid
= thread_info
->private->tid
;
980 thread_info
= find_thread_pid (ptid
);
981 snprintf (buf
, sizeof (buf
), "Thread 0x%lx (LWP %ld)",
982 tid
, GET_LWP (ptid
));
987 if (target_beneath
->to_pid_to_str (ptid
))
988 return target_beneath
->to_pid_to_str (ptid
);
990 return normal_pid_to_str (ptid
);
993 /* Return a string describing the state of the thread specified by
997 thread_db_extra_thread_info (struct thread_info
*info
)
999 if (info
->private == NULL
)
1002 if (info
->private->dying
)
1008 /* Get the address of the thread local variable in load module LM which
1009 is stored at OFFSET within the thread local storage for thread PTID. */
1012 thread_db_get_thread_local_address (ptid_t ptid
,
1016 struct thread_info
*thread_info
;
1018 /* If we have not discovered any threads yet, check now. */
1019 if (!have_threads ())
1020 thread_db_find_new_threads ();
1022 /* Find the matching thread. */
1023 thread_info
= find_thread_pid (ptid
);
1025 if (thread_info
!= NULL
&& thread_info
->private != NULL
)
1030 /* glibc doesn't provide the needed interface. */
1031 if (!td_thr_tls_get_addr_p
)
1032 throw_error (TLS_NO_LIBRARY_SUPPORT_ERROR
,
1033 _("No TLS library support"));
1035 /* Caller should have verified that lm != 0. */
1036 gdb_assert (lm
!= 0);
1038 /* Finally, get the address of the variable. */
1039 err
= td_thr_tls_get_addr_p (&thread_info
->private->th
,
1040 (void *)(size_t) lm
,
1043 #ifdef THREAD_DB_HAS_TD_NOTALLOC
1044 /* The memory hasn't been allocated, yet. */
1045 if (err
== TD_NOTALLOC
)
1046 /* Now, if libthread_db provided the initialization image's
1047 address, we *could* try to build a non-lvalue value from
1048 the initialization image. */
1049 throw_error (TLS_NOT_ALLOCATED_YET_ERROR
,
1050 _("TLS not allocated yet"));
1053 /* Something else went wrong. */
1055 throw_error (TLS_GENERIC_ERROR
,
1056 (("%s")), thread_db_err_str (err
));
1058 /* Cast assuming host == target. Joy. */
1059 /* Do proper sign extension for the target. */
1060 gdb_assert (exec_bfd
);
1061 return (bfd_get_sign_extend_vma (exec_bfd
) > 0
1062 ? (CORE_ADDR
) (intptr_t) address
1063 : (CORE_ADDR
) (uintptr_t) address
);
1066 if (target_beneath
->to_get_thread_local_address
)
1067 return target_beneath
->to_get_thread_local_address (ptid
, lm
, offset
);
1069 throw_error (TLS_GENERIC_ERROR
,
1070 _("TLS not supported on this target"));
1074 init_thread_db_ops (void)
1076 thread_db_ops
.to_shortname
= "multi-thread";
1077 thread_db_ops
.to_longname
= "multi-threaded child process.";
1078 thread_db_ops
.to_doc
= "Threads and pthreads support.";
1079 thread_db_ops
.to_detach
= thread_db_detach
;
1080 thread_db_ops
.to_wait
= thread_db_wait
;
1081 thread_db_ops
.to_mourn_inferior
= thread_db_mourn_inferior
;
1082 thread_db_ops
.to_find_new_threads
= thread_db_find_new_threads
;
1083 thread_db_ops
.to_pid_to_str
= thread_db_pid_to_str
;
1084 thread_db_ops
.to_stratum
= thread_stratum
;
1085 thread_db_ops
.to_has_thread_control
= tc_schedlock
;
1086 thread_db_ops
.to_get_thread_local_address
1087 = thread_db_get_thread_local_address
;
1088 thread_db_ops
.to_extra_thread_info
= thread_db_extra_thread_info
;
1089 thread_db_ops
.to_can_async_p
= thread_db_can_async_p
;
1090 thread_db_ops
.to_is_async_p
= thread_db_is_async_p
;
1091 thread_db_ops
.to_async
= thread_db_async
;
1092 thread_db_ops
.to_async_mask
= thread_db_async_mask
;
1093 thread_db_ops
.to_magic
= OPS_MAGIC
;
1097 _initialize_thread_db (void)
1099 /* Only initialize the module if we can load libthread_db. */
1100 if (thread_db_load ())
1102 init_thread_db_ops ();
1103 add_target (&thread_db_ops
);
1105 /* Add ourselves to objfile event chain. */
1106 observer_attach_new_objfile (thread_db_new_objfile
);