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
)
238 return thread
->private != NULL
;
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
)
750 struct regcache
*regcache
= get_thread_regcache (ptid
);
751 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
758 /* Bail out early if we're not at a thread event breakpoint. */
759 stop_pc
= regcache_read_pc (regcache
)
760 - gdbarch_decr_pc_after_break (gdbarch
);
761 if (stop_pc
!= td_create_bp_addr
&& stop_pc
!= td_death_bp_addr
)
764 /* If we are at a create breakpoint, we do not know what new lwp
765 was created and cannot specifically locate the event message for it.
766 We have to call td_ta_event_getmsg() to get
767 the latest message. Since we have no way of correlating whether
768 the event message we get back corresponds to our breakpoint, we must
769 loop and read all event messages, processing them appropriately.
770 This guarantees we will process the correct message before continuing
773 Currently, death events are not enabled. If they are enabled,
774 the death event can use the td_thr_event_getmsg() interface to
775 get the message specifically for that lwp and avoid looping
782 err
= td_ta_event_getmsg_p (thread_agent
, &msg
);
788 error (_("Cannot get thread event message: %s"),
789 thread_db_err_str (err
));
792 err
= td_thr_get_info_p (msg
.th_p
, &ti
);
794 error (_("Cannot get thread info: %s"), thread_db_err_str (err
));
796 ptid
= ptid_build (GET_PID (ptid
), ti
.ti_lid
, 0);
801 /* Call attach_thread whether or not we already know about a
802 thread with this thread ID. */
803 attach_thread (ptid
, msg
.th_p
, &ti
);
809 if (!in_thread_list (ptid
))
810 error (_("Spurious thread death event."));
812 detach_thread (ptid
);
817 error (_("Spurious thread event."));
824 thread_db_wait (ptid_t ptid
, struct target_waitstatus
*ourstatus
)
826 ptid
= target_beneath
->to_wait (ptid
, ourstatus
);
828 if (ourstatus
->kind
== TARGET_WAITKIND_IGNORE
)
831 if (ourstatus
->kind
== TARGET_WAITKIND_EXITED
832 || ourstatus
->kind
== TARGET_WAITKIND_SIGNALLED
)
833 return pid_to_ptid (-1);
835 if (ourstatus
->kind
== TARGET_WAITKIND_EXECD
)
837 remove_thread_event_breakpoints ();
838 unpush_target (&thread_db_ops
);
841 return pid_to_ptid (GET_PID (ptid
));
844 /* If we do not know about the main thread yet, this would be a good time to
846 if (ourstatus
->kind
== TARGET_WAITKIND_STOPPED
&& !have_threads ())
847 thread_db_find_new_threads ();
849 if (ourstatus
->kind
== TARGET_WAITKIND_STOPPED
850 && ourstatus
->value
.sig
== TARGET_SIGNAL_TRAP
)
851 /* Check for a thread event. */
856 /* Change ptids back into the higher level PID + TID format. If
857 the thread is dead and no longer on the thread list, we will
858 get back a dead ptid. This can occur if the thread death
859 event gets postponed by other simultaneous events. In such a
860 case, we want to just ignore the event and continue on. */
862 ptid
= thread_from_lwp (ptid
);
863 if (GET_PID (ptid
) == -1)
864 ourstatus
->kind
= TARGET_WAITKIND_SPURIOUS
;
871 thread_db_mourn_inferior (void)
873 /* Forget about the child's process ID. We shouldn't need it
877 target_beneath
->to_mourn_inferior ();
879 /* Delete the old thread event breakpoints. Do this after mourning
880 the inferior, so that we don't try to uninsert them. */
881 remove_thread_event_breakpoints ();
883 /* Detach thread_db target ops. */
884 unpush_target (&thread_db_ops
);
889 thread_db_can_async_p (void)
891 return target_beneath
->to_can_async_p ();
895 thread_db_is_async_p (void)
897 return target_beneath
->to_is_async_p ();
901 thread_db_async (void (*callback
) (enum inferior_event_type event_type
,
902 void *context
), void *context
)
904 return target_beneath
->to_async (callback
, context
);
908 thread_db_async_mask (int mask
)
910 return target_beneath
->to_async_mask (mask
);
914 find_new_threads_callback (const td_thrhandle_t
*th_p
, void *data
)
919 struct thread_info
*tp
;
921 err
= td_thr_get_info_p (th_p
, &ti
);
923 error (_("find_new_threads_callback: cannot get thread info: %s"),
924 thread_db_err_str (err
));
926 if (ti
.ti_state
== TD_THR_UNKNOWN
|| ti
.ti_state
== TD_THR_ZOMBIE
)
927 return 0; /* A zombie -- ignore. */
929 ptid
= ptid_build (GET_PID (inferior_ptid
), ti
.ti_lid
, 0);
933 /* A thread ID of zero means that this is the main thread, but
934 glibc has not yet initialized thread-local storage and the
935 pthread library. We do not know what the thread's TID will
936 be yet. Just enable event reporting and otherwise ignore
939 err
= td_thr_event_enable_p (th_p
, 1);
941 error (_("Cannot enable thread event reporting for %s: %s"),
942 target_pid_to_str (ptid
), thread_db_err_str (err
));
947 tp
= find_thread_pid (ptid
);
948 if (tp
== NULL
|| tp
->private == NULL
)
949 attach_thread (ptid
, th_p
, &ti
);
955 thread_db_find_new_threads (void)
959 /* Iterate over all user-space threads to discover new threads. */
960 err
= td_ta_thr_iter_p (thread_agent
, find_new_threads_callback
, NULL
,
961 TD_THR_ANY_STATE
, TD_THR_LOWEST_PRIORITY
,
962 TD_SIGNO_MASK
, TD_THR_ANY_USER_FLAGS
);
964 error (_("Cannot find new threads: %s"), thread_db_err_str (err
));
968 thread_db_pid_to_str (ptid_t ptid
)
970 struct thread_info
*thread_info
= find_thread_pid (ptid
);
972 if (thread_info
!= NULL
&& thread_info
->private != NULL
)
977 tid
= thread_info
->private->tid
;
978 thread_info
= find_thread_pid (ptid
);
979 snprintf (buf
, sizeof (buf
), "Thread 0x%lx (LWP %ld)",
980 tid
, GET_LWP (ptid
));
985 if (target_beneath
->to_pid_to_str (ptid
))
986 return target_beneath
->to_pid_to_str (ptid
);
988 return normal_pid_to_str (ptid
);
991 /* Return a string describing the state of the thread specified by
995 thread_db_extra_thread_info (struct thread_info
*info
)
997 if (info
->private == NULL
)
1000 if (info
->private->dying
)
1006 /* Get the address of the thread local variable in load module LM which
1007 is stored at OFFSET within the thread local storage for thread PTID. */
1010 thread_db_get_thread_local_address (ptid_t ptid
,
1014 struct thread_info
*thread_info
;
1016 /* If we have not discovered any threads yet, check now. */
1017 if (!have_threads ())
1018 thread_db_find_new_threads ();
1020 /* Find the matching thread. */
1021 thread_info
= find_thread_pid (ptid
);
1023 if (thread_info
!= NULL
&& thread_info
->private != NULL
)
1028 /* glibc doesn't provide the needed interface. */
1029 if (!td_thr_tls_get_addr_p
)
1030 throw_error (TLS_NO_LIBRARY_SUPPORT_ERROR
,
1031 _("No TLS library support"));
1033 /* Caller should have verified that lm != 0. */
1034 gdb_assert (lm
!= 0);
1036 /* Finally, get the address of the variable. */
1037 err
= td_thr_tls_get_addr_p (&thread_info
->private->th
,
1038 (void *)(size_t) lm
,
1041 #ifdef THREAD_DB_HAS_TD_NOTALLOC
1042 /* The memory hasn't been allocated, yet. */
1043 if (err
== TD_NOTALLOC
)
1044 /* Now, if libthread_db provided the initialization image's
1045 address, we *could* try to build a non-lvalue value from
1046 the initialization image. */
1047 throw_error (TLS_NOT_ALLOCATED_YET_ERROR
,
1048 _("TLS not allocated yet"));
1051 /* Something else went wrong. */
1053 throw_error (TLS_GENERIC_ERROR
,
1054 (("%s")), thread_db_err_str (err
));
1056 /* Cast assuming host == target. Joy. */
1057 /* Do proper sign extension for the target. */
1058 gdb_assert (exec_bfd
);
1059 return (bfd_get_sign_extend_vma (exec_bfd
) > 0
1060 ? (CORE_ADDR
) (intptr_t) address
1061 : (CORE_ADDR
) (uintptr_t) address
);
1064 if (target_beneath
->to_get_thread_local_address
)
1065 return target_beneath
->to_get_thread_local_address (ptid
, lm
, offset
);
1067 throw_error (TLS_GENERIC_ERROR
,
1068 _("TLS not supported on this target"));
1072 init_thread_db_ops (void)
1074 thread_db_ops
.to_shortname
= "multi-thread";
1075 thread_db_ops
.to_longname
= "multi-threaded child process.";
1076 thread_db_ops
.to_doc
= "Threads and pthreads support.";
1077 thread_db_ops
.to_detach
= thread_db_detach
;
1078 thread_db_ops
.to_wait
= thread_db_wait
;
1079 thread_db_ops
.to_mourn_inferior
= thread_db_mourn_inferior
;
1080 thread_db_ops
.to_find_new_threads
= thread_db_find_new_threads
;
1081 thread_db_ops
.to_pid_to_str
= thread_db_pid_to_str
;
1082 thread_db_ops
.to_stratum
= thread_stratum
;
1083 thread_db_ops
.to_has_thread_control
= tc_schedlock
;
1084 thread_db_ops
.to_get_thread_local_address
1085 = thread_db_get_thread_local_address
;
1086 thread_db_ops
.to_extra_thread_info
= thread_db_extra_thread_info
;
1087 thread_db_ops
.to_can_async_p
= thread_db_can_async_p
;
1088 thread_db_ops
.to_is_async_p
= thread_db_is_async_p
;
1089 thread_db_ops
.to_async
= thread_db_async
;
1090 thread_db_ops
.to_async_mask
= thread_db_async_mask
;
1091 thread_db_ops
.to_magic
= OPS_MAGIC
;
1095 _initialize_thread_db (void)
1097 /* Only initialize the module if we can load libthread_db. */
1098 if (thread_db_load ())
1100 init_thread_db_ops ();
1101 add_target (&thread_db_ops
);
1103 /* Add ourselves to objfile event chain. */
1104 observer_attach_new_objfile (thread_db_new_objfile
);