1 /* libthread_db assisted debugging support, generic parts.
3 Copyright 1999, 2000, 2001, 2003, 2004 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA. */
24 #include "gdb_assert.h"
26 #include "gdb_proc_service.h"
27 #include "gdb_thread_db.h"
30 #include "gdbthread.h"
36 #include "solib-svr4.h"
38 #ifdef HAVE_GNU_LIBC_VERSION_H
39 #include <gnu/libc-version.h>
42 #ifndef LIBTHREAD_DB_SO
43 #define LIBTHREAD_DB_SO "libthread_db.so.1"
46 /* If we're running on GNU/Linux, we must explicitly attach to any new
49 /* FIXME: There is certainly some room for improvements:
51 - Bypass libthread_db when fetching or storing registers for
52 threads bound to a LWP. */
54 /* This module's target vector. */
55 static struct target_ops thread_db_ops
;
57 /* The target vector that we call for things this module can't handle. */
58 static struct target_ops
*target_beneath
;
60 /* Pointer to the next function on the objfile event chain. */
61 static void (*target_new_objfile_chain
) (struct objfile
* objfile
);
63 /* Non-zero if we're using this module's target vector. */
64 static int using_thread_db
;
66 /* Non-zero if we have to keep this module's target vector active
68 static int keep_thread_db
;
70 /* Non-zero if we have determined the signals used by the threads
72 static int thread_signals
;
73 static sigset_t thread_stop_set
;
74 static sigset_t thread_print_set
;
76 /* Structure that identifies the child process for the
77 <proc_service.h> interface. */
78 static struct ps_prochandle proc_handle
;
80 /* Connection to the libthread_db library. */
81 static td_thragent_t
*thread_agent
;
83 /* Pointers to the libthread_db functions. */
85 static td_err_e (*td_init_p
) (void);
87 static td_err_e (*td_ta_new_p
) (struct ps_prochandle
* ps
,
89 static td_err_e (*td_ta_map_id2thr_p
) (const td_thragent_t
*ta
, thread_t pt
,
90 td_thrhandle_t
*__th
);
91 static td_err_e (*td_ta_map_lwp2thr_p
) (const td_thragent_t
*ta
,
92 lwpid_t lwpid
, td_thrhandle_t
*th
);
93 static td_err_e (*td_ta_thr_iter_p
) (const td_thragent_t
*ta
,
94 td_thr_iter_f
*callback
, void *cbdata_p
,
95 td_thr_state_e state
, int ti_pri
,
96 sigset_t
*ti_sigmask_p
,
97 unsigned int ti_user_flags
);
98 static td_err_e (*td_ta_event_addr_p
) (const td_thragent_t
*ta
,
99 td_event_e event
, td_notify_t
*ptr
);
100 static td_err_e (*td_ta_set_event_p
) (const td_thragent_t
*ta
,
101 td_thr_events_t
*event
);
102 static td_err_e (*td_ta_event_getmsg_p
) (const td_thragent_t
*ta
,
103 td_event_msg_t
*msg
);
105 static td_err_e (*td_thr_validate_p
) (const td_thrhandle_t
*th
);
106 static td_err_e (*td_thr_get_info_p
) (const td_thrhandle_t
*th
,
107 td_thrinfo_t
*infop
);
108 static td_err_e (*td_thr_getfpregs_p
) (const td_thrhandle_t
*th
,
109 gdb_prfpregset_t
*regset
);
110 static td_err_e (*td_thr_getgregs_p
) (const td_thrhandle_t
*th
,
112 static td_err_e (*td_thr_setfpregs_p
) (const td_thrhandle_t
*th
,
113 const gdb_prfpregset_t
*fpregs
);
114 static td_err_e (*td_thr_setgregs_p
) (const td_thrhandle_t
*th
,
116 static td_err_e (*td_thr_event_enable_p
) (const td_thrhandle_t
*th
,
119 static td_err_e (*td_thr_tls_get_addr_p
) (const td_thrhandle_t
*th
,
121 size_t offset
, void **address
);
123 /* Location of the thread creation event breakpoint. The code at this
124 location in the child process will be called by the pthread library
125 whenever a new thread is created. By setting a special breakpoint
126 at this location, GDB can detect when a new thread is created. We
127 obtain this location via the td_ta_event_addr call. */
128 static CORE_ADDR td_create_bp_addr
;
130 /* Location of the thread death event breakpoint. */
131 static CORE_ADDR td_death_bp_addr
;
133 /* Prototypes for local functions. */
134 static void thread_db_find_new_threads (void);
135 static void attach_thread (ptid_t ptid
, const td_thrhandle_t
*th_p
,
136 const td_thrinfo_t
*ti_p
, int verbose
);
137 static void detach_thread (ptid_t ptid
, int verbose
);
140 /* Building process ids. */
142 #define GET_PID(ptid) ptid_get_pid (ptid)
143 #define GET_LWP(ptid) ptid_get_lwp (ptid)
144 #define GET_THREAD(ptid) ptid_get_tid (ptid)
146 #define is_lwp(ptid) (GET_LWP (ptid) != 0)
147 #define is_thread(ptid) (GET_THREAD (ptid) != 0)
149 #define BUILD_LWP(lwp, pid) ptid_build (pid, lwp, 0)
150 #define BUILD_THREAD(tid, pid) ptid_build (pid, 0, tid)
153 /* Use "struct private_thread_info" to cache thread state. This is
154 a substantial optimization. */
156 struct private_thread_info
158 /* Flag set when we see a TD_DEATH event for this thread. */
159 unsigned int dying
:1;
161 /* Cached thread state. */
162 unsigned int th_valid
:1;
163 unsigned int ti_valid
:1;
171 thread_db_err_str (td_err_e err
)
178 return "generic 'call succeeded'";
180 return "generic error";
182 return "no thread to satisfy query";
184 return "no sync handle to satisfy query";
186 return "no LWP to satisfy query";
188 return "invalid process handle";
190 return "invalid thread handle";
192 return "invalid synchronization handle";
194 return "invalid thread agent";
196 return "invalid key";
198 return "no event message for getmsg";
200 return "FPU register set not available";
202 return "application not linked with libthread";
204 return "requested event is not supported";
206 return "capability not available";
208 return "debugger service failed";
210 return "operation not applicable to";
212 return "no thread-specific data for this thread";
214 return "malloc failed";
216 return "only part of register set was written/read";
218 return "X register set not available for this thread";
220 snprintf (buf
, sizeof (buf
), "unknown thread_db error '%d'", err
);
226 thread_db_state_str (td_thr_state_e state
)
233 return "stopped by debugger";
242 case TD_THR_STOPPED_ASLEEP
:
243 return "stopped by debugger AND blocked";
245 snprintf (buf
, sizeof (buf
), "unknown thread_db state %d", state
);
250 /* A callback function for td_ta_thr_iter, which we use to map all
253 THP is a handle to the current thread; if INFOP is not NULL, the
254 struct thread_info associated with this thread is returned in
257 If the thread is a zombie, TD_THR_ZOMBIE is returned. Otherwise,
258 zero is returned to indicate success. */
261 thread_get_info_callback (const td_thrhandle_t
*thp
, void *infop
)
265 struct thread_info
*thread_info
;
268 err
= td_thr_get_info_p (thp
, &ti
);
270 error ("thread_get_info_callback: cannot get thread info: %s",
271 thread_db_err_str (err
));
273 /* Fill the cache. */
274 thread_ptid
= BUILD_THREAD (ti
.ti_tid
, GET_PID (inferior_ptid
));
275 thread_info
= find_thread_pid (thread_ptid
);
277 /* In the case of a zombie thread, don't continue. We don't want to
278 attach to it thinking it is a new thread and we don't want to mark
280 if (ti
.ti_state
== TD_THR_UNKNOWN
|| ti
.ti_state
== TD_THR_ZOMBIE
)
283 *(struct thread_info
**) infop
= thread_info
;
284 return TD_THR_ZOMBIE
;
287 if (thread_info
== NULL
)
289 /* New thread. Attach to it now (why wait?). */
290 attach_thread (thread_ptid
, thp
, &ti
, 1);
291 thread_info
= find_thread_pid (thread_ptid
);
292 gdb_assert (thread_info
!= NULL
);
295 memcpy (&thread_info
->private->th
, thp
, sizeof (*thp
));
296 thread_info
->private->th_valid
= 1;
297 memcpy (&thread_info
->private->ti
, &ti
, sizeof (ti
));
298 thread_info
->private->ti_valid
= 1;
301 *(struct thread_info
**) infop
= thread_info
;
306 /* Accessor functions for the thread_db information, with caching. */
309 thread_db_map_id2thr (struct thread_info
*thread_info
, int fatal
)
313 if (thread_info
->private->th_valid
)
316 err
= td_ta_map_id2thr_p (thread_agent
, GET_THREAD (thread_info
->ptid
),
317 &thread_info
->private->th
);
321 error ("Cannot find thread %ld: %s",
322 (long) GET_THREAD (thread_info
->ptid
),
323 thread_db_err_str (err
));
326 thread_info
->private->th_valid
= 1;
329 static td_thrinfo_t
*
330 thread_db_get_info (struct thread_info
*thread_info
)
334 if (thread_info
->private->ti_valid
)
335 return &thread_info
->private->ti
;
337 if (!thread_info
->private->th_valid
)
338 thread_db_map_id2thr (thread_info
, 1);
341 td_thr_get_info_p (&thread_info
->private->th
, &thread_info
->private->ti
);
343 error ("thread_db_get_info: cannot get thread info: %s",
344 thread_db_err_str (err
));
346 thread_info
->private->ti_valid
= 1;
347 return &thread_info
->private->ti
;
350 /* Convert between user-level thread ids and LWP ids. */
353 thread_from_lwp (ptid_t ptid
)
357 struct thread_info
*thread_info
;
360 if (GET_LWP (ptid
) == 0)
361 ptid
= BUILD_LWP (GET_PID (ptid
), GET_PID (ptid
));
363 gdb_assert (is_lwp (ptid
));
365 err
= td_ta_map_lwp2thr_p (thread_agent
, GET_LWP (ptid
), &th
);
367 error ("Cannot find user-level thread for LWP %ld: %s",
368 GET_LWP (ptid
), thread_db_err_str (err
));
372 /* Fetch the thread info. If we get back TD_THR_ZOMBIE, then the
373 event thread has already died. If another gdb interface has called
374 thread_alive() previously, the thread won't be found on the thread list
375 anymore. In that case, we don't want to process this ptid anymore
376 to avoid the possibility of later treating it as a newly
377 discovered thread id that we should add to the list. Thus,
378 we return a -1 ptid which is also how the thread list marks a
380 if (thread_get_info_callback (&th
, &thread_info
) == TD_THR_ZOMBIE
381 && thread_info
== NULL
)
382 return pid_to_ptid (-1);
384 gdb_assert (thread_info
&& thread_info
->private->ti_valid
);
386 return BUILD_THREAD (thread_info
->private->ti
.ti_tid
, GET_PID (ptid
));
390 lwp_from_thread (ptid_t ptid
)
392 struct thread_info
*thread_info
;
395 if (!is_thread (ptid
))
398 thread_info
= find_thread_pid (ptid
);
399 thread_db_get_info (thread_info
);
401 return BUILD_LWP (thread_info
->private->ti
.ti_lid
, GET_PID (ptid
));
406 thread_db_init (struct target_ops
*target
)
408 target_beneath
= target
;
412 verbose_dlsym (void *handle
, const char *name
)
414 void *sym
= dlsym (handle
, name
);
416 warning ("Symbol \"%s\" not found in libthread_db: %s", name
, dlerror ());
421 thread_db_load (void)
426 handle
= dlopen (LIBTHREAD_DB_SO
, RTLD_NOW
);
429 fprintf_filtered (gdb_stderr
, "\n\ndlopen failed on '%s' - %s\n",
430 LIBTHREAD_DB_SO
, dlerror ());
431 fprintf_filtered (gdb_stderr
,
432 "GDB will not be able to debug pthreads.\n\n");
436 /* Initialize pointers to the dynamic library functions we will use.
437 Essential functions first. */
439 td_init_p
= verbose_dlsym (handle
, "td_init");
440 if (td_init_p
== NULL
)
443 td_ta_new_p
= verbose_dlsym (handle
, "td_ta_new");
444 if (td_ta_new_p
== NULL
)
447 td_ta_map_id2thr_p
= verbose_dlsym (handle
, "td_ta_map_id2thr");
448 if (td_ta_map_id2thr_p
== NULL
)
451 td_ta_map_lwp2thr_p
= verbose_dlsym (handle
, "td_ta_map_lwp2thr");
452 if (td_ta_map_lwp2thr_p
== NULL
)
455 td_ta_thr_iter_p
= verbose_dlsym (handle
, "td_ta_thr_iter");
456 if (td_ta_thr_iter_p
== NULL
)
459 td_thr_validate_p
= verbose_dlsym (handle
, "td_thr_validate");
460 if (td_thr_validate_p
== NULL
)
463 td_thr_get_info_p
= verbose_dlsym (handle
, "td_thr_get_info");
464 if (td_thr_get_info_p
== NULL
)
467 td_thr_getfpregs_p
= verbose_dlsym (handle
, "td_thr_getfpregs");
468 if (td_thr_getfpregs_p
== NULL
)
471 td_thr_getgregs_p
= verbose_dlsym (handle
, "td_thr_getgregs");
472 if (td_thr_getgregs_p
== NULL
)
475 td_thr_setfpregs_p
= verbose_dlsym (handle
, "td_thr_setfpregs");
476 if (td_thr_setfpregs_p
== NULL
)
479 td_thr_setgregs_p
= verbose_dlsym (handle
, "td_thr_setgregs");
480 if (td_thr_setgregs_p
== NULL
)
483 /* Initialize the library. */
487 warning ("Cannot initialize libthread_db: %s", thread_db_err_str (err
));
491 /* These are not essential. */
492 td_ta_event_addr_p
= dlsym (handle
, "td_ta_event_addr");
493 td_ta_set_event_p
= dlsym (handle
, "td_ta_set_event");
494 td_ta_event_getmsg_p
= dlsym (handle
, "td_ta_event_getmsg");
495 td_thr_event_enable_p
= dlsym (handle
, "td_thr_event_enable");
496 td_thr_tls_get_addr_p
= dlsym (handle
, "td_thr_tls_get_addr");
502 enable_thread_event (td_thragent_t
*thread_agent
, int event
, CORE_ADDR
*bp
)
507 /* Get the breakpoint address for thread EVENT. */
508 err
= td_ta_event_addr_p (thread_agent
, event
, ¬ify
);
512 /* Set up the breakpoint. */
513 (*bp
) = gdbarch_convert_from_func_ptr_addr (current_gdbarch
,
514 (CORE_ADDR
) notify
.u
.bptaddr
,
516 create_thread_event_breakpoint ((*bp
));
522 enable_thread_event_reporting (void)
524 td_thr_events_t events
;
527 #ifdef HAVE_GNU_LIBC_VERSION_H
528 const char *libc_version
;
529 int libc_major
, libc_minor
;
532 /* We cannot use the thread event reporting facility if these
533 functions aren't available. */
534 if (td_ta_event_addr_p
== NULL
|| td_ta_set_event_p
== NULL
535 || td_ta_event_getmsg_p
== NULL
|| td_thr_event_enable_p
== NULL
)
538 /* Set the process wide mask saying which events we're interested in. */
539 td_event_emptyset (&events
);
540 td_event_addset (&events
, TD_CREATE
);
542 #ifdef HAVE_GNU_LIBC_VERSION_H
543 /* FIXME: kettenis/2000-04-23: The event reporting facility is
544 broken for TD_DEATH events in glibc 2.1.3, so don't enable it for
546 libc_version
= gnu_get_libc_version ();
547 if (sscanf (libc_version
, "%d.%d", &libc_major
, &libc_minor
) == 2
548 && (libc_major
> 2 || (libc_major
== 2 && libc_minor
> 1)))
550 td_event_addset (&events
, TD_DEATH
);
552 err
= td_ta_set_event_p (thread_agent
, &events
);
555 warning ("Unable to set global thread event mask: %s",
556 thread_db_err_str (err
));
560 /* Delete previous thread event breakpoints, if any. */
561 remove_thread_event_breakpoints ();
562 td_create_bp_addr
= 0;
563 td_death_bp_addr
= 0;
565 /* Set up the thread creation event. */
566 err
= enable_thread_event (thread_agent
, TD_CREATE
, &td_create_bp_addr
);
569 warning ("Unable to get location for thread creation breakpoint: %s",
570 thread_db_err_str (err
));
574 /* Set up the thread death event. */
575 err
= enable_thread_event (thread_agent
, TD_DEATH
, &td_death_bp_addr
);
578 warning ("Unable to get location for thread death breakpoint: %s",
579 thread_db_err_str (err
));
585 disable_thread_event_reporting (void)
587 td_thr_events_t events
;
589 /* Set the process wide mask saying we aren't interested in any
591 td_event_emptyset (&events
);
592 td_ta_set_event_p (thread_agent
, &events
);
594 /* Delete thread event breakpoints, if any. */
595 remove_thread_event_breakpoints ();
596 td_create_bp_addr
= 0;
597 td_death_bp_addr
= 0;
601 check_thread_signals (void)
603 #ifdef GET_THREAD_SIGNALS
609 GET_THREAD_SIGNALS (&mask
);
610 sigemptyset (&thread_stop_set
);
611 sigemptyset (&thread_print_set
);
613 for (i
= 1; i
< NSIG
; i
++)
615 if (sigismember (&mask
, i
))
617 if (signal_stop_update (target_signal_from_host (i
), 0))
618 sigaddset (&thread_stop_set
, i
);
619 if (signal_print_update (target_signal_from_host (i
), 0))
620 sigaddset (&thread_print_set
, i
);
629 thread_db_new_objfile (struct objfile
*objfile
)
633 /* First time through, report that libthread_db was successfuly
634 loaded. Can't print this in in thread_db_load as, at that stage,
635 the interpreter and it's console haven't started. The real
636 problem here is that libthread_db is loaded too early - it should
637 only be loaded when there is a program to debug. */
643 const char *library
= NULL
;
645 if (dladdr ((*td_ta_new_p
), &info
) != 0)
646 library
= info
.dli_fname
;
649 /* Paranoid - don't let a NULL path slip through. */
650 library
= LIBTHREAD_DB_SO
;
651 printf_unfiltered ("Using host libthread_db library \"%s\".\n",
657 /* Don't attempt to use thread_db on targets which can not run
659 if (objfile
== NULL
|| !target_has_execution
)
661 /* All symbols have been discarded. If the thread_db target is
662 active, deactivate it now. */
665 gdb_assert (proc_handle
.pid
== 0);
666 unpush_target (&thread_db_ops
);
676 /* Nothing to do. The thread library was already detected and the
677 target vector was already activated. */
680 /* Initialize the structure that identifies the child process. Note
681 that at this point there is no guarantee that we actually have a
683 proc_handle
.pid
= GET_PID (inferior_ptid
);
685 /* Now attempt to open a connection to the thread library. */
686 err
= td_ta_new_p (&proc_handle
, &thread_agent
);
690 /* No thread library was detected. */
694 printf_unfiltered ("[Thread debugging using libthread_db enabled]\n");
696 /* The thread library was detected. Activate the thread_db target. */
697 push_target (&thread_db_ops
);
700 /* If the thread library was detected in the main symbol file
701 itself, we assume that the program was statically linked
702 against the thread library and well have to keep this
703 module's target vector activated until forever... Well, at
704 least until all symbols have been discarded anyway (see
706 if (objfile
== symfile_objfile
)
708 gdb_assert (proc_handle
.pid
== 0);
712 /* We can only poke around if there actually is a child process.
713 If there is no child process alive, postpone the steps below
714 until one has been created. */
715 if (proc_handle
.pid
!= 0)
717 enable_thread_event_reporting ();
718 thread_db_find_new_threads ();
723 warning ("Cannot initialize thread debugging library: %s",
724 thread_db_err_str (err
));
729 if (target_new_objfile_chain
)
730 target_new_objfile_chain (objfile
);
733 /* Attach to a new thread. This function is called when we receive a
734 TD_CREATE event or when we iterate over all threads and find one
735 that wasn't already in our list. */
738 attach_thread (ptid_t ptid
, const td_thrhandle_t
*th_p
,
739 const td_thrinfo_t
*ti_p
, int verbose
)
741 struct thread_info
*tp
;
744 /* If we're being called after a TD_CREATE event, we may already
745 know about this thread. There are two ways this can happen. We
746 may have iterated over all threads between the thread creation
747 and the TD_CREATE event, for instance when the user has issued
748 the `info threads' command before the SIGTRAP for hitting the
749 thread creation breakpoint was reported. Alternatively, the
750 thread may have exited and a new one been created with the same
751 thread ID. In the first case we don't need to do anything; in
752 the second case we should discard information about the dead
753 thread and attach to the new one. */
754 if (in_thread_list (ptid
))
756 tp
= find_thread_pid (ptid
);
757 gdb_assert (tp
!= NULL
);
759 if (!tp
->private->dying
)
762 delete_thread (ptid
);
765 check_thread_signals ();
767 /* Add the thread to GDB's thread list. */
768 tp
= add_thread (ptid
);
769 tp
->private = xmalloc (sizeof (struct private_thread_info
));
770 memset (tp
->private, 0, sizeof (struct private_thread_info
));
773 printf_unfiltered ("[New %s]\n", target_pid_to_str (ptid
));
775 if (ti_p
->ti_state
== TD_THR_UNKNOWN
|| ti_p
->ti_state
== TD_THR_ZOMBIE
)
776 return; /* A zombie thread -- do not attach. */
778 /* Under GNU/Linux, we have to attach to each and every thread. */
780 ATTACH_LWP (BUILD_LWP (ti_p
->ti_lid
, GET_PID (ptid
)), 0);
783 /* Enable thread event reporting for this thread. */
784 err
= td_thr_event_enable_p (th_p
, 1);
786 error ("Cannot enable thread event reporting for %s: %s",
787 target_pid_to_str (ptid
), thread_db_err_str (err
));
791 thread_db_attach (char *args
, int from_tty
)
793 target_beneath
->to_attach (args
, from_tty
);
795 /* Destroy thread info; it's no longer valid. */
798 /* The child process is now the actual multi-threaded
799 program. Snatch its process ID... */
800 proc_handle
.pid
= GET_PID (inferior_ptid
);
802 /* ...and perform the remaining initialization steps. */
803 enable_thread_event_reporting ();
804 thread_db_find_new_threads ();
808 detach_thread (ptid_t ptid
, int verbose
)
810 struct thread_info
*thread_info
;
813 printf_unfiltered ("[%s exited]\n", target_pid_to_str (ptid
));
815 /* Don't delete the thread now, because it still reports as active
816 until it has executed a few instructions after the event
817 breakpoint - if we deleted it now, "info threads" would cause us
818 to re-attach to it. Just mark it as having had a TD_DEATH
819 event. This means that we won't delete it from our thread list
820 until we notice that it's dead (via prune_threads), or until
821 something re-uses its thread ID. */
822 thread_info
= find_thread_pid (ptid
);
823 gdb_assert (thread_info
!= NULL
);
824 thread_info
->private->dying
= 1;
828 thread_db_detach (char *args
, int from_tty
)
830 disable_thread_event_reporting ();
832 /* There's no need to save & restore inferior_ptid here, since the
833 inferior is supposed to be survive this function call. */
834 inferior_ptid
= lwp_from_thread (inferior_ptid
);
836 /* Forget about the child's process ID. We shouldn't need it
840 target_beneath
->to_detach (args
, from_tty
);
844 clear_lwpid_callback (struct thread_info
*thread
, void *dummy
)
846 /* If we know that our thread implementation is 1-to-1, we could save
847 a certain amount of information; it's not clear how much, so we
848 are always conservative. */
850 thread
->private->th_valid
= 0;
851 thread
->private->ti_valid
= 0;
857 thread_db_resume (ptid_t ptid
, int step
, enum target_signal signo
)
859 struct cleanup
*old_chain
= save_inferior_ptid ();
861 if (GET_PID (ptid
) == -1)
862 inferior_ptid
= lwp_from_thread (inferior_ptid
);
863 else if (is_thread (ptid
))
864 ptid
= lwp_from_thread (ptid
);
866 /* Clear cached data which may not be valid after the resume. */
867 iterate_over_threads (clear_lwpid_callback
, NULL
);
869 target_beneath
->to_resume (ptid
, step
, signo
);
871 do_cleanups (old_chain
);
874 /* Check if PID is currently stopped at the location of a thread event
875 breakpoint location. If it is, read the event message and act upon
879 check_event (ptid_t ptid
)
887 /* Bail out early if we're not at a thread event breakpoint. */
888 stop_pc
= read_pc_pid (ptid
) - DECR_PC_AFTER_BREAK
;
889 if (stop_pc
!= td_create_bp_addr
&& stop_pc
!= td_death_bp_addr
)
892 /* If we are at a create breakpoint, we do not know what new lwp
893 was created and cannot specifically locate the event message for it.
894 We have to call td_ta_event_getmsg() to get
895 the latest message. Since we have no way of correlating whether
896 the event message we get back corresponds to our breakpoint, we must
897 loop and read all event messages, processing them appropriately.
898 This guarantees we will process the correct message before continuing
901 Currently, death events are not enabled. If they are enabled,
902 the death event can use the td_thr_event_getmsg() interface to
903 get the message specifically for that lwp and avoid looping
910 err
= td_ta_event_getmsg_p (thread_agent
, &msg
);
916 error ("Cannot get thread event message: %s",
917 thread_db_err_str (err
));
920 err
= td_thr_get_info_p (msg
.th_p
, &ti
);
922 error ("Cannot get thread info: %s", thread_db_err_str (err
));
924 ptid
= BUILD_THREAD (ti
.ti_tid
, GET_PID (ptid
));
929 /* Call attach_thread whether or not we already know about a
930 thread with this thread ID. */
931 attach_thread (ptid
, msg
.th_p
, &ti
, 1);
937 if (!in_thread_list (ptid
))
938 error ("Spurious thread death event.");
940 detach_thread (ptid
, 1);
945 error ("Spurious thread event.");
952 thread_db_wait (ptid_t ptid
, struct target_waitstatus
*ourstatus
)
954 extern ptid_t trap_ptid
;
956 if (GET_PID (ptid
) != -1 && is_thread (ptid
))
957 ptid
= lwp_from_thread (ptid
);
959 ptid
= target_beneath
->to_wait (ptid
, ourstatus
);
961 if (proc_handle
.pid
== 0)
962 /* The current child process isn't the actual multi-threaded
963 program yet, so don't try to do any special thread-specific
964 post-processing and bail out early. */
967 if (ourstatus
->kind
== TARGET_WAITKIND_EXITED
)
968 return pid_to_ptid (-1);
970 if (ourstatus
->kind
== TARGET_WAITKIND_STOPPED
971 && ourstatus
->value
.sig
== TARGET_SIGNAL_TRAP
)
972 /* Check for a thread event. */
975 if (!ptid_equal (trap_ptid
, null_ptid
))
976 trap_ptid
= thread_from_lwp (trap_ptid
);
978 /* Change the ptid back into the higher level PID + TID format.
979 If the thread is dead and no longer on the thread list, we will
980 get back a dead ptid. This can occur if the thread death event
981 gets postponed by other simultaneous events. In such a case,
982 we want to just ignore the event and continue on. */
983 ptid
= thread_from_lwp (ptid
);
984 if (GET_PID (ptid
) == -1)
985 ourstatus
->kind
= TARGET_WAITKIND_SPURIOUS
;
991 thread_db_xfer_memory (CORE_ADDR memaddr
, char *myaddr
, int len
, int write
,
992 struct mem_attrib
*attrib
, struct target_ops
*target
)
994 struct cleanup
*old_chain
= save_inferior_ptid ();
997 if (is_thread (inferior_ptid
))
999 /* FIXME: This seems to be necessary to make sure breakpoints
1001 if (!target_thread_alive (inferior_ptid
))
1002 inferior_ptid
= pid_to_ptid (GET_PID (inferior_ptid
));
1004 inferior_ptid
= lwp_from_thread (inferior_ptid
);
1008 target_beneath
->to_xfer_memory (memaddr
, myaddr
, len
, write
, attrib
,
1011 do_cleanups (old_chain
);
1016 thread_db_fetch_registers (int regno
)
1018 struct thread_info
*thread_info
;
1019 prgregset_t gregset
;
1020 gdb_prfpregset_t fpregset
;
1023 if (!is_thread (inferior_ptid
))
1025 /* Pass the request to the target beneath us. */
1026 target_beneath
->to_fetch_registers (regno
);
1030 thread_info
= find_thread_pid (inferior_ptid
);
1031 thread_db_map_id2thr (thread_info
, 1);
1033 err
= td_thr_getgregs_p (&thread_info
->private->th
, gregset
);
1035 error ("Cannot fetch general-purpose registers for thread %ld: %s",
1036 (long) GET_THREAD (inferior_ptid
), thread_db_err_str (err
));
1038 err
= td_thr_getfpregs_p (&thread_info
->private->th
, &fpregset
);
1040 error ("Cannot get floating-point registers for thread %ld: %s",
1041 (long) GET_THREAD (inferior_ptid
), thread_db_err_str (err
));
1043 /* Note that we must call supply_gregset after calling the thread_db
1044 routines because the thread_db routines call ps_lgetgregs and
1045 friends which clobber GDB's register cache. */
1046 supply_gregset ((gdb_gregset_t
*) gregset
);
1047 supply_fpregset (&fpregset
);
1051 thread_db_store_registers (int regno
)
1053 prgregset_t gregset
;
1054 gdb_prfpregset_t fpregset
;
1056 struct thread_info
*thread_info
;
1058 if (!is_thread (inferior_ptid
))
1060 /* Pass the request to the target beneath us. */
1061 target_beneath
->to_store_registers (regno
);
1065 thread_info
= find_thread_pid (inferior_ptid
);
1066 thread_db_map_id2thr (thread_info
, 1);
1070 char raw
[MAX_REGISTER_SIZE
];
1072 deprecated_read_register_gen (regno
, raw
);
1073 thread_db_fetch_registers (-1);
1074 supply_register (regno
, raw
);
1077 fill_gregset ((gdb_gregset_t
*) gregset
, -1);
1078 fill_fpregset (&fpregset
, -1);
1080 err
= td_thr_setgregs_p (&thread_info
->private->th
, gregset
);
1082 error ("Cannot store general-purpose registers for thread %ld: %s",
1083 (long) GET_THREAD (inferior_ptid
), thread_db_err_str (err
));
1084 err
= td_thr_setfpregs_p (&thread_info
->private->th
, &fpregset
);
1086 error ("Cannot store floating-point registers for thread %ld: %s",
1087 (long) GET_THREAD (inferior_ptid
), thread_db_err_str (err
));
1091 thread_db_kill (void)
1093 /* There's no need to save & restore inferior_ptid here, since the
1094 inferior isn't supposed to survive this function call. */
1095 inferior_ptid
= lwp_from_thread (inferior_ptid
);
1096 target_beneath
->to_kill ();
1100 thread_db_create_inferior (char *exec_file
, char *allargs
, char **env
,
1103 if (!keep_thread_db
)
1105 unpush_target (&thread_db_ops
);
1106 using_thread_db
= 0;
1109 target_beneath
->to_create_inferior (exec_file
, allargs
, env
, from_tty
);
1113 thread_db_post_startup_inferior (ptid_t ptid
)
1115 if (proc_handle
.pid
== 0)
1117 /* The child process is now the actual multi-threaded
1118 program. Snatch its process ID... */
1119 proc_handle
.pid
= GET_PID (ptid
);
1121 /* ...and perform the remaining initialization steps. */
1122 enable_thread_event_reporting ();
1123 thread_db_find_new_threads ();
1128 thread_db_mourn_inferior (void)
1130 remove_thread_event_breakpoints ();
1132 /* Forget about the child's process ID. We shouldn't need it
1134 proc_handle
.pid
= 0;
1136 target_beneath
->to_mourn_inferior ();
1138 /* Detach thread_db target ops if not dealing with a statically
1139 linked threaded program. This allows a corefile to be debugged
1140 after finishing debugging of a threaded program. At present,
1141 debugging a statically-linked threaded program is broken, but
1142 the check is added below in the event that it is fixed in the
1144 if (!keep_thread_db
)
1146 unpush_target (&thread_db_ops
);
1147 using_thread_db
= 0;
1152 thread_db_thread_alive (ptid_t ptid
)
1157 if (is_thread (ptid
))
1159 struct thread_info
*thread_info
;
1160 thread_info
= find_thread_pid (ptid
);
1162 thread_db_map_id2thr (thread_info
, 0);
1163 if (!thread_info
->private->th_valid
)
1166 err
= td_thr_validate_p (&thread_info
->private->th
);
1170 if (!thread_info
->private->ti_valid
)
1173 td_thr_get_info_p (&thread_info
->private->th
,
1174 &thread_info
->private->ti
);
1177 thread_info
->private->ti_valid
= 1;
1180 if (thread_info
->private->ti
.ti_state
== TD_THR_UNKNOWN
1181 || thread_info
->private->ti
.ti_state
== TD_THR_ZOMBIE
)
1182 return 0; /* A zombie thread. */
1187 if (target_beneath
->to_thread_alive
)
1188 return target_beneath
->to_thread_alive (ptid
);
1194 find_new_threads_callback (const td_thrhandle_t
*th_p
, void *data
)
1200 err
= td_thr_get_info_p (th_p
, &ti
);
1202 error ("find_new_threads_callback: cannot get thread info: %s",
1203 thread_db_err_str (err
));
1205 if (ti
.ti_state
== TD_THR_UNKNOWN
|| ti
.ti_state
== TD_THR_ZOMBIE
)
1206 return 0; /* A zombie -- ignore. */
1208 ptid
= BUILD_THREAD (ti
.ti_tid
, GET_PID (inferior_ptid
));
1210 if (!in_thread_list (ptid
))
1211 attach_thread (ptid
, th_p
, &ti
, 1);
1217 thread_db_find_new_threads (void)
1221 /* Iterate over all user-space threads to discover new threads. */
1222 err
= td_ta_thr_iter_p (thread_agent
, find_new_threads_callback
, NULL
,
1223 TD_THR_ANY_STATE
, TD_THR_LOWEST_PRIORITY
,
1224 TD_SIGNO_MASK
, TD_THR_ANY_USER_FLAGS
);
1226 error ("Cannot find new threads: %s", thread_db_err_str (err
));
1230 thread_db_pid_to_str (ptid_t ptid
)
1232 if (is_thread (ptid
))
1234 static char buf
[64];
1237 struct thread_info
*thread_info
;
1239 thread_info
= find_thread_pid (ptid
);
1240 thread_db_map_id2thr (thread_info
, 0);
1241 if (!thread_info
->private->th_valid
)
1243 snprintf (buf
, sizeof (buf
), "Thread %ld (Missing)",
1248 ti_p
= thread_db_get_info (thread_info
);
1250 if (ti_p
->ti_state
== TD_THR_ACTIVE
&& ti_p
->ti_lid
!= 0)
1252 snprintf (buf
, sizeof (buf
), "Thread %ld (LWP %d)",
1253 (long) ti_p
->ti_tid
, ti_p
->ti_lid
);
1257 snprintf (buf
, sizeof (buf
), "Thread %ld (%s)",
1258 (long) ti_p
->ti_tid
,
1259 thread_db_state_str (ti_p
->ti_state
));
1265 if (target_beneath
->to_pid_to_str (ptid
))
1266 return target_beneath
->to_pid_to_str (ptid
);
1268 return normal_pid_to_str (ptid
);
1271 /* Get the address of the thread local variable in OBJFILE which is
1272 stored at OFFSET within the thread local storage for thread PTID. */
1275 thread_db_get_thread_local_address (ptid_t ptid
, struct objfile
*objfile
,
1278 if (is_thread (ptid
))
1280 int objfile_is_library
= (objfile
->flags
& OBJF_SHARED
);
1284 struct thread_info
*thread_info
;
1286 /* glibc doesn't provide the needed interface. */
1287 if (!td_thr_tls_get_addr_p
)
1288 error ("Cannot find thread-local variables in this thread library.");
1290 /* Get the address of the link map for this objfile. */
1291 lm
= svr4_fetch_objfile_link_map (objfile
);
1293 /* Whoops, we couldn't find one. Bail out. */
1296 if (objfile_is_library
)
1297 error ("Cannot find shared library `%s' link_map in dynamic"
1298 " linker's module list", objfile
->name
);
1300 error ("Cannot find executable file `%s' link_map in dynamic"
1301 " linker's module list", objfile
->name
);
1304 /* Get info about the thread. */
1305 thread_info
= find_thread_pid (ptid
);
1306 thread_db_map_id2thr (thread_info
, 1);
1308 /* Finally, get the address of the variable. */
1309 err
= td_thr_tls_get_addr_p (&thread_info
->private->th
, (void *) lm
,
1312 #ifdef THREAD_DB_HAS_TD_NOTALLOC
1313 /* The memory hasn't been allocated, yet. */
1314 if (err
== TD_NOTALLOC
)
1316 /* Now, if libthread_db provided the initialization image's
1317 address, we *could* try to build a non-lvalue value from
1318 the initialization image. */
1319 if (objfile_is_library
)
1320 error ("The inferior has not yet allocated storage for"
1321 " thread-local variables in\n"
1322 "the shared library `%s'\n"
1323 "for the thread %ld",
1324 objfile
->name
, (long) GET_THREAD (ptid
));
1326 error ("The inferior has not yet allocated storage for"
1327 " thread-local variables in\n"
1328 "the executable `%s'\n"
1329 "for the thread %ld",
1330 objfile
->name
, (long) GET_THREAD (ptid
));
1334 /* Something else went wrong. */
1337 if (objfile_is_library
)
1338 error ("Cannot find thread-local storage for thread %ld, "
1339 "shared library %s:\n%s",
1340 (long) GET_THREAD (ptid
),
1341 objfile
->name
, thread_db_err_str (err
));
1343 error ("Cannot find thread-local storage for thread %ld, "
1344 "executable file %s:\n%s",
1345 (long) GET_THREAD (ptid
),
1346 objfile
->name
, thread_db_err_str (err
));
1349 /* Cast assuming host == target. Joy. */
1350 return (CORE_ADDR
) address
;
1353 if (target_beneath
->to_get_thread_local_address
)
1354 return target_beneath
->to_get_thread_local_address (ptid
, objfile
,
1357 error ("Cannot find thread-local values on this target.");
1361 init_thread_db_ops (void)
1363 thread_db_ops
.to_shortname
= "multi-thread";
1364 thread_db_ops
.to_longname
= "multi-threaded child process.";
1365 thread_db_ops
.to_doc
= "Threads and pthreads support.";
1366 thread_db_ops
.to_attach
= thread_db_attach
;
1367 thread_db_ops
.to_detach
= thread_db_detach
;
1368 thread_db_ops
.to_resume
= thread_db_resume
;
1369 thread_db_ops
.to_wait
= thread_db_wait
;
1370 thread_db_ops
.to_fetch_registers
= thread_db_fetch_registers
;
1371 thread_db_ops
.to_store_registers
= thread_db_store_registers
;
1372 thread_db_ops
.to_xfer_memory
= thread_db_xfer_memory
;
1373 thread_db_ops
.to_kill
= thread_db_kill
;
1374 thread_db_ops
.to_create_inferior
= thread_db_create_inferior
;
1375 thread_db_ops
.to_post_startup_inferior
= thread_db_post_startup_inferior
;
1376 thread_db_ops
.to_mourn_inferior
= thread_db_mourn_inferior
;
1377 thread_db_ops
.to_thread_alive
= thread_db_thread_alive
;
1378 thread_db_ops
.to_find_new_threads
= thread_db_find_new_threads
;
1379 thread_db_ops
.to_pid_to_str
= thread_db_pid_to_str
;
1380 thread_db_ops
.to_stratum
= thread_stratum
;
1381 thread_db_ops
.to_has_thread_control
= tc_schedlock
;
1382 thread_db_ops
.to_get_thread_local_address
1383 = thread_db_get_thread_local_address
;
1384 thread_db_ops
.to_magic
= OPS_MAGIC
;
1388 _initialize_thread_db (void)
1390 /* Only initialize the module if we can load libthread_db. */
1391 if (thread_db_load ())
1393 init_thread_db_ops ();
1394 add_target (&thread_db_ops
);
1396 /* Add ourselves to objfile event chain. */
1397 target_new_objfile_chain
= deprecated_target_new_objfile_hook
;
1398 deprecated_target_new_objfile_hook
= thread_db_new_objfile
;