1 /* libthread_db assisted debugging support, generic parts.
3 Copyright 1999, 2000, 2001, 2003, 2004, 2005
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 2 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, write to the Free Software
20 Foundation, Inc., 59 Temple Place - Suite 330,
21 Boston, MA 02111-1307, USA. */
25 #include "gdb_assert.h"
27 #include "gdb_proc_service.h"
28 #include "gdb_thread_db.h"
31 #include "exceptions.h"
32 #include "gdbthread.h"
38 #include "solib-svr4.h"
40 #ifdef HAVE_GNU_LIBC_VERSION_H
41 #include <gnu/libc-version.h>
44 #ifndef LIBTHREAD_DB_SO
45 #define LIBTHREAD_DB_SO "libthread_db.so.1"
48 /* If we're running on GNU/Linux, we must explicitly attach to any new
51 /* FIXME: There is certainly some room for improvements:
53 - Bypass libthread_db when fetching or storing registers for
54 threads bound to a LWP. */
56 /* This module's target vector. */
57 static struct target_ops thread_db_ops
;
59 /* The target vector that we call for things this module can't handle. */
60 static struct target_ops
*target_beneath
;
62 /* Pointer to the next function on the objfile event chain. */
63 static void (*target_new_objfile_chain
) (struct objfile
* objfile
);
65 /* Non-zero if we're using this module's target vector. */
66 static int using_thread_db
;
68 /* Non-zero if we have determined the signals used by the threads
70 static int thread_signals
;
71 static sigset_t thread_stop_set
;
72 static sigset_t thread_print_set
;
74 /* Structure that identifies the child process for the
75 <proc_service.h> interface. */
76 static struct ps_prochandle proc_handle
;
78 /* Connection to the libthread_db library. */
79 static td_thragent_t
*thread_agent
;
81 /* Pointers to the libthread_db functions. */
83 static td_err_e (*td_init_p
) (void);
85 static td_err_e (*td_ta_new_p
) (struct ps_prochandle
* ps
,
87 static td_err_e (*td_ta_map_id2thr_p
) (const td_thragent_t
*ta
, thread_t pt
,
88 td_thrhandle_t
*__th
);
89 static td_err_e (*td_ta_map_lwp2thr_p
) (const td_thragent_t
*ta
,
90 lwpid_t lwpid
, td_thrhandle_t
*th
);
91 static td_err_e (*td_ta_thr_iter_p
) (const td_thragent_t
*ta
,
92 td_thr_iter_f
*callback
, void *cbdata_p
,
93 td_thr_state_e state
, int ti_pri
,
94 sigset_t
*ti_sigmask_p
,
95 unsigned int ti_user_flags
);
96 static td_err_e (*td_ta_event_addr_p
) (const td_thragent_t
*ta
,
97 td_event_e event
, td_notify_t
*ptr
);
98 static td_err_e (*td_ta_set_event_p
) (const td_thragent_t
*ta
,
99 td_thr_events_t
*event
);
100 static td_err_e (*td_ta_event_getmsg_p
) (const td_thragent_t
*ta
,
101 td_event_msg_t
*msg
);
103 static td_err_e (*td_thr_validate_p
) (const td_thrhandle_t
*th
);
104 static td_err_e (*td_thr_get_info_p
) (const td_thrhandle_t
*th
,
105 td_thrinfo_t
*infop
);
106 static td_err_e (*td_thr_getfpregs_p
) (const td_thrhandle_t
*th
,
107 gdb_prfpregset_t
*regset
);
108 static td_err_e (*td_thr_getgregs_p
) (const td_thrhandle_t
*th
,
110 static td_err_e (*td_thr_setfpregs_p
) (const td_thrhandle_t
*th
,
111 const gdb_prfpregset_t
*fpregs
);
112 static td_err_e (*td_thr_setgregs_p
) (const td_thrhandle_t
*th
,
114 static td_err_e (*td_thr_event_enable_p
) (const td_thrhandle_t
*th
,
117 static td_err_e (*td_thr_tls_get_addr_p
) (const td_thrhandle_t
*th
,
119 size_t offset
, void **address
);
121 /* Location of the thread creation event breakpoint. The code at this
122 location in the child process will be called by the pthread library
123 whenever a new thread is created. By setting a special breakpoint
124 at this location, GDB can detect when a new thread is created. We
125 obtain this location via the td_ta_event_addr call. */
126 static CORE_ADDR td_create_bp_addr
;
128 /* Location of the thread death event breakpoint. */
129 static CORE_ADDR td_death_bp_addr
;
131 /* Prototypes for local functions. */
132 static void thread_db_find_new_threads (void);
133 static void attach_thread (ptid_t ptid
, const td_thrhandle_t
*th_p
,
134 const td_thrinfo_t
*ti_p
, int verbose
);
135 static void detach_thread (ptid_t ptid
, int verbose
);
138 /* Building process ids. */
140 #define GET_PID(ptid) ptid_get_pid (ptid)
141 #define GET_LWP(ptid) ptid_get_lwp (ptid)
142 #define GET_THREAD(ptid) ptid_get_tid (ptid)
144 #define is_lwp(ptid) (GET_LWP (ptid) != 0)
145 #define is_thread(ptid) (GET_THREAD (ptid) != 0)
147 #define BUILD_LWP(lwp, pid) ptid_build (pid, lwp, 0)
150 /* Use "struct private_thread_info" to cache thread state. This is
151 a substantial optimization. */
153 struct private_thread_info
155 /* Flag set when we see a TD_DEATH event for this thread. */
156 unsigned int dying
:1;
158 /* Cached thread state. */
159 unsigned int th_valid
:1;
160 unsigned int ti_valid
:1;
168 thread_db_err_str (td_err_e err
)
175 return "generic 'call succeeded'";
177 return "generic error";
179 return "no thread to satisfy query";
181 return "no sync handle to satisfy query";
183 return "no LWP to satisfy query";
185 return "invalid process handle";
187 return "invalid thread handle";
189 return "invalid synchronization handle";
191 return "invalid thread agent";
193 return "invalid key";
195 return "no event message for getmsg";
197 return "FPU register set not available";
199 return "application not linked with libthread";
201 return "requested event is not supported";
203 return "capability not available";
205 return "debugger service failed";
207 return "operation not applicable to";
209 return "no thread-specific data for this thread";
211 return "malloc failed";
213 return "only part of register set was written/read";
215 return "X register set not available for this thread";
217 snprintf (buf
, sizeof (buf
), "unknown thread_db error '%d'", err
);
223 thread_db_state_str (td_thr_state_e state
)
230 return "stopped by debugger";
239 case TD_THR_STOPPED_ASLEEP
:
240 return "stopped by debugger AND blocked";
242 snprintf (buf
, sizeof (buf
), "unknown thread_db state %d", state
);
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
, ti
.ti_tid
);
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 if (thread_info
!= NULL
)
282 memcpy (&thread_info
->private->th
, thp
, sizeof (*thp
));
283 thread_info
->private->th_valid
= 1;
284 memcpy (&thread_info
->private->ti
, &ti
, sizeof (ti
));
285 thread_info
->private->ti_valid
= 1;
287 return TD_THR_ZOMBIE
;
290 if (thread_info
== NULL
)
292 /* New thread. Attach to it now (why wait?). */
293 attach_thread (thread_ptid
, thp
, &ti
, 1);
294 thread_info
= find_thread_pid (thread_ptid
);
295 gdb_assert (thread_info
!= NULL
);
298 memcpy (&thread_info
->private->th
, thp
, sizeof (*thp
));
299 thread_info
->private->th_valid
= 1;
300 memcpy (&thread_info
->private->ti
, &ti
, sizeof (ti
));
301 thread_info
->private->ti_valid
= 1;
304 *(struct thread_info
**) infop
= thread_info
;
309 /* Accessor functions for the thread_db information, with caching. */
312 thread_db_map_id2thr (struct thread_info
*thread_info
, int fatal
)
316 if (thread_info
->private->th_valid
)
319 err
= td_ta_map_id2thr_p (thread_agent
, GET_THREAD (thread_info
->ptid
),
320 &thread_info
->private->th
);
324 error (_("Cannot find thread %ld: %s"),
325 (long) GET_THREAD (thread_info
->ptid
),
326 thread_db_err_str (err
));
329 thread_info
->private->th_valid
= 1;
332 static td_thrinfo_t
*
333 thread_db_get_info (struct thread_info
*thread_info
)
337 if (thread_info
->private->ti_valid
)
338 return &thread_info
->private->ti
;
340 if (!thread_info
->private->th_valid
)
341 thread_db_map_id2thr (thread_info
, 1);
344 td_thr_get_info_p (&thread_info
->private->th
, &thread_info
->private->ti
);
346 error (_("thread_db_get_info: cannot get thread info: %s"),
347 thread_db_err_str (err
));
349 thread_info
->private->ti_valid
= 1;
350 return &thread_info
->private->ti
;
353 /* Convert between user-level thread ids and LWP ids. */
356 thread_from_lwp (ptid_t ptid
)
360 struct thread_info
*thread_info
;
363 if (GET_LWP (ptid
) == 0)
364 ptid
= BUILD_LWP (GET_PID (ptid
), GET_PID (ptid
));
366 gdb_assert (is_lwp (ptid
));
368 err
= td_ta_map_lwp2thr_p (thread_agent
, GET_LWP (ptid
), &th
);
370 error (_("Cannot find user-level thread for LWP %ld: %s"),
371 GET_LWP (ptid
), thread_db_err_str (err
));
375 /* Fetch the thread info. If we get back TD_THR_ZOMBIE, then the
376 event thread has already died. If another gdb interface has called
377 thread_alive() previously, the thread won't be found on the thread list
378 anymore. In that case, we don't want to process this ptid anymore
379 to avoid the possibility of later treating it as a newly
380 discovered thread id that we should add to the list. Thus,
381 we return a -1 ptid which is also how the thread list marks a
383 if (thread_get_info_callback (&th
, &thread_info
) == TD_THR_ZOMBIE
384 && thread_info
== NULL
)
385 return pid_to_ptid (-1);
387 gdb_assert (thread_info
&& thread_info
->private->ti_valid
);
389 return ptid_build (GET_PID (ptid
), GET_LWP (ptid
),
390 thread_info
->private->ti
.ti_tid
);
394 lwp_from_thread (ptid_t ptid
)
396 return BUILD_LWP (GET_LWP (ptid
), GET_PID (ptid
));
401 thread_db_init (struct target_ops
*target
)
403 target_beneath
= target
;
407 verbose_dlsym (void *handle
, const char *name
)
409 void *sym
= dlsym (handle
, name
);
411 warning (_("Symbol \"%s\" not found in libthread_db: %s"), name
, dlerror ());
416 thread_db_load (void)
421 handle
= dlopen (LIBTHREAD_DB_SO
, RTLD_NOW
);
424 fprintf_filtered (gdb_stderr
, "\n\ndlopen failed on '%s' - %s\n",
425 LIBTHREAD_DB_SO
, dlerror ());
426 fprintf_filtered (gdb_stderr
,
427 "GDB will not be able to debug pthreads.\n\n");
431 /* Initialize pointers to the dynamic library functions we will use.
432 Essential functions first. */
434 td_init_p
= verbose_dlsym (handle
, "td_init");
435 if (td_init_p
== NULL
)
438 td_ta_new_p
= verbose_dlsym (handle
, "td_ta_new");
439 if (td_ta_new_p
== NULL
)
442 td_ta_map_id2thr_p
= verbose_dlsym (handle
, "td_ta_map_id2thr");
443 if (td_ta_map_id2thr_p
== NULL
)
446 td_ta_map_lwp2thr_p
= verbose_dlsym (handle
, "td_ta_map_lwp2thr");
447 if (td_ta_map_lwp2thr_p
== NULL
)
450 td_ta_thr_iter_p
= verbose_dlsym (handle
, "td_ta_thr_iter");
451 if (td_ta_thr_iter_p
== NULL
)
454 td_thr_validate_p
= verbose_dlsym (handle
, "td_thr_validate");
455 if (td_thr_validate_p
== NULL
)
458 td_thr_get_info_p
= verbose_dlsym (handle
, "td_thr_get_info");
459 if (td_thr_get_info_p
== NULL
)
462 td_thr_getfpregs_p
= verbose_dlsym (handle
, "td_thr_getfpregs");
463 if (td_thr_getfpregs_p
== NULL
)
466 td_thr_getgregs_p
= verbose_dlsym (handle
, "td_thr_getgregs");
467 if (td_thr_getgregs_p
== NULL
)
470 td_thr_setfpregs_p
= verbose_dlsym (handle
, "td_thr_setfpregs");
471 if (td_thr_setfpregs_p
== NULL
)
474 td_thr_setgregs_p
= verbose_dlsym (handle
, "td_thr_setgregs");
475 if (td_thr_setgregs_p
== NULL
)
478 /* Initialize the library. */
482 warning (_("Cannot initialize libthread_db: %s"), thread_db_err_str (err
));
486 /* These are not essential. */
487 td_ta_event_addr_p
= dlsym (handle
, "td_ta_event_addr");
488 td_ta_set_event_p
= dlsym (handle
, "td_ta_set_event");
489 td_ta_event_getmsg_p
= dlsym (handle
, "td_ta_event_getmsg");
490 td_thr_event_enable_p
= dlsym (handle
, "td_thr_event_enable");
491 td_thr_tls_get_addr_p
= dlsym (handle
, "td_thr_tls_get_addr");
497 enable_thread_event (td_thragent_t
*thread_agent
, int event
, CORE_ADDR
*bp
)
502 /* Get the breakpoint address for thread EVENT. */
503 err
= td_ta_event_addr_p (thread_agent
, event
, ¬ify
);
507 /* Set up the breakpoint. */
508 (*bp
) = gdbarch_convert_from_func_ptr_addr (current_gdbarch
,
509 (CORE_ADDR
) notify
.u
.bptaddr
,
511 create_thread_event_breakpoint ((*bp
));
517 enable_thread_event_reporting (void)
519 td_thr_events_t events
;
522 #ifdef HAVE_GNU_LIBC_VERSION_H
523 const char *libc_version
;
524 int libc_major
, libc_minor
;
527 /* We cannot use the thread event reporting facility if these
528 functions aren't available. */
529 if (td_ta_event_addr_p
== NULL
|| td_ta_set_event_p
== NULL
530 || td_ta_event_getmsg_p
== NULL
|| td_thr_event_enable_p
== NULL
)
533 /* Set the process wide mask saying which events we're interested in. */
534 td_event_emptyset (&events
);
535 td_event_addset (&events
, TD_CREATE
);
537 #ifdef HAVE_GNU_LIBC_VERSION_H
538 /* FIXME: kettenis/2000-04-23: The event reporting facility is
539 broken for TD_DEATH events in glibc 2.1.3, so don't enable it for
541 libc_version
= gnu_get_libc_version ();
542 if (sscanf (libc_version
, "%d.%d", &libc_major
, &libc_minor
) == 2
543 && (libc_major
> 2 || (libc_major
== 2 && libc_minor
> 1)))
545 td_event_addset (&events
, TD_DEATH
);
547 err
= td_ta_set_event_p (thread_agent
, &events
);
550 warning (_("Unable to set global thread event mask: %s"),
551 thread_db_err_str (err
));
555 /* Delete previous thread event breakpoints, if any. */
556 remove_thread_event_breakpoints ();
557 td_create_bp_addr
= 0;
558 td_death_bp_addr
= 0;
560 /* Set up the thread creation event. */
561 err
= enable_thread_event (thread_agent
, TD_CREATE
, &td_create_bp_addr
);
564 warning (_("Unable to get location for thread creation breakpoint: %s"),
565 thread_db_err_str (err
));
569 /* Set up the thread death event. */
570 err
= enable_thread_event (thread_agent
, TD_DEATH
, &td_death_bp_addr
);
573 warning (_("Unable to get location for thread death breakpoint: %s"),
574 thread_db_err_str (err
));
580 disable_thread_event_reporting (void)
582 td_thr_events_t events
;
584 /* Set the process wide mask saying we aren't interested in any
586 td_event_emptyset (&events
);
587 td_ta_set_event_p (thread_agent
, &events
);
589 /* Delete thread event breakpoints, if any. */
590 remove_thread_event_breakpoints ();
591 td_create_bp_addr
= 0;
592 td_death_bp_addr
= 0;
596 check_thread_signals (void)
598 #ifdef GET_THREAD_SIGNALS
604 GET_THREAD_SIGNALS (&mask
);
605 sigemptyset (&thread_stop_set
);
606 sigemptyset (&thread_print_set
);
608 for (i
= 1; i
< NSIG
; i
++)
610 if (sigismember (&mask
, i
))
612 if (signal_stop_update (target_signal_from_host (i
), 0))
613 sigaddset (&thread_stop_set
, i
);
614 if (signal_print_update (target_signal_from_host (i
), 0))
615 sigaddset (&thread_print_set
, i
);
624 thread_db_new_objfile (struct objfile
*objfile
)
628 /* First time through, report that libthread_db was successfuly
629 loaded. Can't print this in in thread_db_load as, at that stage,
630 the interpreter and it's console haven't started. The real
631 problem here is that libthread_db is loaded too early - it should
632 only be loaded when there is a program to debug. */
638 const char *library
= NULL
;
640 if (dladdr ((*td_ta_new_p
), &info
) != 0)
641 library
= info
.dli_fname
;
644 /* Paranoid - don't let a NULL path slip through. */
645 library
= LIBTHREAD_DB_SO
;
646 printf_unfiltered (_("Using host libthread_db library \"%s\".\n"),
652 /* Don't attempt to use thread_db on targets which can not run
654 if (objfile
== NULL
|| !target_has_execution
)
656 /* All symbols have been discarded. If the thread_db target is
657 active, deactivate it now. */
660 gdb_assert (proc_handle
.pid
== 0);
661 unpush_target (&thread_db_ops
);
669 /* Nothing to do. The thread library was already detected and the
670 target vector was already activated. */
673 /* Initialize the structure that identifies the child process. Note
674 that at this point there is no guarantee that we actually have a
676 proc_handle
.pid
= GET_PID (inferior_ptid
);
678 /* Now attempt to open a connection to the thread library. */
679 err
= td_ta_new_p (&proc_handle
, &thread_agent
);
683 /* No thread library was detected. */
687 printf_unfiltered (_("[Thread debugging using libthread_db enabled]\n"));
689 /* The thread library was detected. Activate the thread_db target. */
690 push_target (&thread_db_ops
);
693 enable_thread_event_reporting ();
694 thread_db_find_new_threads ();
698 warning (_("Cannot initialize thread debugging library: %s"),
699 thread_db_err_str (err
));
704 if (target_new_objfile_chain
)
705 target_new_objfile_chain (objfile
);
708 /* Attach to a new thread. This function is called when we receive a
709 TD_CREATE event or when we iterate over all threads and find one
710 that wasn't already in our list. */
713 attach_thread (ptid_t ptid
, const td_thrhandle_t
*th_p
,
714 const td_thrinfo_t
*ti_p
, int verbose
)
716 struct thread_info
*tp
;
719 /* If we're being called after a TD_CREATE event, we may already
720 know about this thread. There are two ways this can happen. We
721 may have iterated over all threads between the thread creation
722 and the TD_CREATE event, for instance when the user has issued
723 the `info threads' command before the SIGTRAP for hitting the
724 thread creation breakpoint was reported. Alternatively, the
725 thread may have exited and a new one been created with the same
726 thread ID. In the first case we don't need to do anything; in
727 the second case we should discard information about the dead
728 thread and attach to the new one. */
729 if (in_thread_list (ptid
))
731 tp
= find_thread_pid (ptid
);
732 gdb_assert (tp
!= NULL
);
734 if (!tp
->private->dying
)
737 delete_thread (ptid
);
740 check_thread_signals ();
742 /* Add the thread to GDB's thread list. */
743 tp
= add_thread (ptid
);
744 tp
->private = xmalloc (sizeof (struct private_thread_info
));
745 memset (tp
->private, 0, sizeof (struct private_thread_info
));
748 printf_unfiltered (_("[New %s]\n"), target_pid_to_str (ptid
));
750 if (ti_p
->ti_state
== TD_THR_UNKNOWN
|| ti_p
->ti_state
== TD_THR_ZOMBIE
)
751 return; /* A zombie thread -- do not attach. */
753 /* Under GNU/Linux, we have to attach to each and every thread. */
755 ATTACH_LWP (BUILD_LWP (ti_p
->ti_lid
, GET_PID (ptid
)), 0);
758 /* Enable thread event reporting for this thread. */
759 err
= td_thr_event_enable_p (th_p
, 1);
761 error (_("Cannot enable thread event reporting for %s: %s"),
762 target_pid_to_str (ptid
), thread_db_err_str (err
));
766 thread_db_attach (char *args
, int from_tty
)
768 target_beneath
->to_attach (args
, from_tty
);
770 /* Destroy thread info; it's no longer valid. */
773 /* The child process is now the actual multi-threaded
774 program. Snatch its process ID... */
775 proc_handle
.pid
= GET_PID (inferior_ptid
);
777 /* ...and perform the remaining initialization steps. */
778 enable_thread_event_reporting ();
779 thread_db_find_new_threads ();
783 detach_thread (ptid_t ptid
, int verbose
)
785 struct thread_info
*thread_info
;
788 printf_unfiltered (_("[%s exited]\n"), target_pid_to_str (ptid
));
790 /* Don't delete the thread now, because it still reports as active
791 until it has executed a few instructions after the event
792 breakpoint - if we deleted it now, "info threads" would cause us
793 to re-attach to it. Just mark it as having had a TD_DEATH
794 event. This means that we won't delete it from our thread list
795 until we notice that it's dead (via prune_threads), or until
796 something re-uses its thread ID. */
797 thread_info
= find_thread_pid (ptid
);
798 gdb_assert (thread_info
!= NULL
);
799 thread_info
->private->dying
= 1;
803 thread_db_detach (char *args
, int from_tty
)
805 disable_thread_event_reporting ();
807 /* There's no need to save & restore inferior_ptid here, since the
808 inferior is supposed to be survive this function call. */
809 inferior_ptid
= lwp_from_thread (inferior_ptid
);
811 /* Forget about the child's process ID. We shouldn't need it
815 target_beneath
->to_detach (args
, from_tty
);
819 clear_lwpid_callback (struct thread_info
*thread
, void *dummy
)
821 /* If we know that our thread implementation is 1-to-1, we could save
822 a certain amount of information; it's not clear how much, so we
823 are always conservative. */
825 thread
->private->th_valid
= 0;
826 thread
->private->ti_valid
= 0;
832 thread_db_resume (ptid_t ptid
, int step
, enum target_signal signo
)
834 struct cleanup
*old_chain
= save_inferior_ptid ();
836 if (GET_PID (ptid
) == -1)
837 inferior_ptid
= lwp_from_thread (inferior_ptid
);
838 else if (is_thread (ptid
))
839 ptid
= lwp_from_thread (ptid
);
841 /* Clear cached data which may not be valid after the resume. */
842 iterate_over_threads (clear_lwpid_callback
, NULL
);
844 target_beneath
->to_resume (ptid
, step
, signo
);
846 do_cleanups (old_chain
);
849 /* Check if PID is currently stopped at the location of a thread event
850 breakpoint location. If it is, read the event message and act upon
854 check_event (ptid_t ptid
)
862 /* Bail out early if we're not at a thread event breakpoint. */
863 stop_pc
= read_pc_pid (ptid
) - DECR_PC_AFTER_BREAK
;
864 if (stop_pc
!= td_create_bp_addr
&& stop_pc
!= td_death_bp_addr
)
867 /* If we are at a create breakpoint, we do not know what new lwp
868 was created and cannot specifically locate the event message for it.
869 We have to call td_ta_event_getmsg() to get
870 the latest message. Since we have no way of correlating whether
871 the event message we get back corresponds to our breakpoint, we must
872 loop and read all event messages, processing them appropriately.
873 This guarantees we will process the correct message before continuing
876 Currently, death events are not enabled. If they are enabled,
877 the death event can use the td_thr_event_getmsg() interface to
878 get the message specifically for that lwp and avoid looping
885 err
= td_ta_event_getmsg_p (thread_agent
, &msg
);
891 error (_("Cannot get thread event message: %s"),
892 thread_db_err_str (err
));
895 err
= td_thr_get_info_p (msg
.th_p
, &ti
);
897 error (_("Cannot get thread info: %s"), thread_db_err_str (err
));
899 ptid
= ptid_build (GET_PID (ptid
), ti
.ti_lid
, ti
.ti_tid
);
904 /* Call attach_thread whether or not we already know about a
905 thread with this thread ID. */
906 attach_thread (ptid
, msg
.th_p
, &ti
, 1);
912 if (!in_thread_list (ptid
))
913 error (_("Spurious thread death event."));
915 detach_thread (ptid
, 1);
920 error (_("Spurious thread event."));
927 thread_db_wait (ptid_t ptid
, struct target_waitstatus
*ourstatus
)
929 extern ptid_t trap_ptid
;
931 if (GET_PID (ptid
) != -1 && is_thread (ptid
))
932 ptid
= lwp_from_thread (ptid
);
934 ptid
= target_beneath
->to_wait (ptid
, ourstatus
);
936 if (proc_handle
.pid
== 0)
937 /* The current child process isn't the actual multi-threaded
938 program yet, so don't try to do any special thread-specific
939 post-processing and bail out early. */
942 if (ourstatus
->kind
== TARGET_WAITKIND_EXITED
)
943 return pid_to_ptid (-1);
945 if (ourstatus
->kind
== TARGET_WAITKIND_STOPPED
946 && ourstatus
->value
.sig
== TARGET_SIGNAL_TRAP
)
947 /* Check for a thread event. */
950 if (!ptid_equal (trap_ptid
, null_ptid
))
951 trap_ptid
= thread_from_lwp (trap_ptid
);
953 /* Change the ptid back into the higher level PID + TID format.
954 If the thread is dead and no longer on the thread list, we will
955 get back a dead ptid. This can occur if the thread death event
956 gets postponed by other simultaneous events. In such a case,
957 we want to just ignore the event and continue on. */
958 ptid
= thread_from_lwp (ptid
);
959 if (GET_PID (ptid
) == -1)
960 ourstatus
->kind
= TARGET_WAITKIND_SPURIOUS
;
966 thread_db_xfer_partial (struct target_ops
*ops
, enum target_object object
,
967 const char *annex
, gdb_byte
*readbuf
,
968 const gdb_byte
*writebuf
, ULONGEST offset
, LONGEST len
)
970 struct cleanup
*old_chain
= save_inferior_ptid ();
973 if (is_thread (inferior_ptid
))
975 /* FIXME: This seems to be necessary to make sure breakpoints
977 if (!target_thread_alive (inferior_ptid
))
978 inferior_ptid
= pid_to_ptid (GET_PID (inferior_ptid
));
980 inferior_ptid
= lwp_from_thread (inferior_ptid
);
983 xfer
= target_beneath
->to_xfer_partial (ops
, object
, annex
,
984 readbuf
, writebuf
, offset
, len
);
986 do_cleanups (old_chain
);
991 thread_db_fetch_registers (int regno
)
993 struct thread_info
*thread_info
;
995 gdb_prfpregset_t fpregset
;
998 if (!is_thread (inferior_ptid
))
1000 /* Pass the request to the target beneath us. */
1001 target_beneath
->to_fetch_registers (regno
);
1005 thread_info
= find_thread_pid (inferior_ptid
);
1006 thread_db_map_id2thr (thread_info
, 1);
1008 err
= td_thr_getgregs_p (&thread_info
->private->th
, gregset
);
1010 error (_("Cannot fetch general-purpose registers for thread %ld: %s"),
1011 (long) GET_THREAD (inferior_ptid
), thread_db_err_str (err
));
1013 err
= td_thr_getfpregs_p (&thread_info
->private->th
, &fpregset
);
1015 error (_("Cannot get floating-point registers for thread %ld: %s"),
1016 (long) GET_THREAD (inferior_ptid
), thread_db_err_str (err
));
1018 /* Note that we must call supply_gregset after calling the thread_db
1019 routines because the thread_db routines call ps_lgetgregs and
1020 friends which clobber GDB's register cache. */
1021 supply_gregset ((gdb_gregset_t
*) gregset
);
1022 supply_fpregset (&fpregset
);
1026 thread_db_store_registers (int regno
)
1028 prgregset_t gregset
;
1029 gdb_prfpregset_t fpregset
;
1031 struct thread_info
*thread_info
;
1033 if (!is_thread (inferior_ptid
))
1035 /* Pass the request to the target beneath us. */
1036 target_beneath
->to_store_registers (regno
);
1040 thread_info
= find_thread_pid (inferior_ptid
);
1041 thread_db_map_id2thr (thread_info
, 1);
1045 char raw
[MAX_REGISTER_SIZE
];
1047 deprecated_read_register_gen (regno
, raw
);
1048 thread_db_fetch_registers (-1);
1049 regcache_raw_supply (current_regcache
, regno
, raw
);
1052 fill_gregset ((gdb_gregset_t
*) gregset
, -1);
1053 fill_fpregset (&fpregset
, -1);
1055 err
= td_thr_setgregs_p (&thread_info
->private->th
, gregset
);
1057 error (_("Cannot store general-purpose registers for thread %ld: %s"),
1058 (long) GET_THREAD (inferior_ptid
), thread_db_err_str (err
));
1059 err
= td_thr_setfpregs_p (&thread_info
->private->th
, &fpregset
);
1061 error (_("Cannot store floating-point registers for thread %ld: %s"),
1062 (long) GET_THREAD (inferior_ptid
), thread_db_err_str (err
));
1066 thread_db_kill (void)
1068 /* There's no need to save & restore inferior_ptid here, since the
1069 inferior isn't supposed to survive this function call. */
1070 inferior_ptid
= lwp_from_thread (inferior_ptid
);
1071 target_beneath
->to_kill ();
1075 thread_db_create_inferior (char *exec_file
, char *allargs
, char **env
,
1078 unpush_target (&thread_db_ops
);
1079 using_thread_db
= 0;
1080 target_beneath
->to_create_inferior (exec_file
, allargs
, env
, from_tty
);
1084 thread_db_post_startup_inferior (ptid_t ptid
)
1086 if (proc_handle
.pid
== 0)
1088 /* The child process is now the actual multi-threaded
1089 program. Snatch its process ID... */
1090 proc_handle
.pid
= GET_PID (ptid
);
1092 /* ...and perform the remaining initialization steps. */
1093 enable_thread_event_reporting ();
1094 thread_db_find_new_threads ();
1099 thread_db_mourn_inferior (void)
1101 remove_thread_event_breakpoints ();
1103 /* Forget about the child's process ID. We shouldn't need it
1105 proc_handle
.pid
= 0;
1107 target_beneath
->to_mourn_inferior ();
1109 /* Detach thread_db target ops. */
1110 unpush_target (&thread_db_ops
);
1111 using_thread_db
= 0;
1115 thread_db_thread_alive (ptid_t ptid
)
1120 if (is_thread (ptid
))
1122 struct thread_info
*thread_info
;
1123 thread_info
= find_thread_pid (ptid
);
1125 thread_db_map_id2thr (thread_info
, 0);
1126 if (!thread_info
->private->th_valid
)
1129 err
= td_thr_validate_p (&thread_info
->private->th
);
1133 if (!thread_info
->private->ti_valid
)
1136 td_thr_get_info_p (&thread_info
->private->th
,
1137 &thread_info
->private->ti
);
1140 thread_info
->private->ti_valid
= 1;
1143 if (thread_info
->private->ti
.ti_state
== TD_THR_UNKNOWN
1144 || thread_info
->private->ti
.ti_state
== TD_THR_ZOMBIE
)
1145 return 0; /* A zombie thread. */
1150 if (target_beneath
->to_thread_alive
)
1151 return target_beneath
->to_thread_alive (ptid
);
1157 find_new_threads_callback (const td_thrhandle_t
*th_p
, void *data
)
1163 err
= td_thr_get_info_p (th_p
, &ti
);
1165 error (_("find_new_threads_callback: cannot get thread info: %s"),
1166 thread_db_err_str (err
));
1168 if (ti
.ti_state
== TD_THR_UNKNOWN
|| ti
.ti_state
== TD_THR_ZOMBIE
)
1169 return 0; /* A zombie -- ignore. */
1171 ptid
= ptid_build (GET_PID (inferior_ptid
), ti
.ti_lid
, ti
.ti_tid
);
1173 if (!in_thread_list (ptid
))
1174 attach_thread (ptid
, th_p
, &ti
, 1);
1180 thread_db_find_new_threads (void)
1184 /* Iterate over all user-space threads to discover new threads. */
1185 err
= td_ta_thr_iter_p (thread_agent
, find_new_threads_callback
, NULL
,
1186 TD_THR_ANY_STATE
, TD_THR_LOWEST_PRIORITY
,
1187 TD_SIGNO_MASK
, TD_THR_ANY_USER_FLAGS
);
1189 error (_("Cannot find new threads: %s"), thread_db_err_str (err
));
1193 thread_db_pid_to_str (ptid_t ptid
)
1195 if (is_thread (ptid
))
1197 static char buf
[64];
1200 struct thread_info
*thread_info
;
1202 thread_info
= find_thread_pid (ptid
);
1203 thread_db_map_id2thr (thread_info
, 0);
1204 if (!thread_info
->private->th_valid
)
1206 snprintf (buf
, sizeof (buf
), "Thread %ld (Missing)",
1211 ti_p
= thread_db_get_info (thread_info
);
1213 if (ti_p
->ti_state
== TD_THR_ACTIVE
&& ti_p
->ti_lid
!= 0)
1215 snprintf (buf
, sizeof (buf
), "Thread %ld (LWP %d)",
1216 (long) ti_p
->ti_tid
, ti_p
->ti_lid
);
1220 snprintf (buf
, sizeof (buf
), "Thread %ld (%s)",
1221 (long) ti_p
->ti_tid
,
1222 thread_db_state_str (ti_p
->ti_state
));
1228 if (target_beneath
->to_pid_to_str (ptid
))
1229 return target_beneath
->to_pid_to_str (ptid
);
1231 return normal_pid_to_str (ptid
);
1234 /* Get the address of the thread local variable in load module LM which
1235 is stored at OFFSET within the thread local storage for thread PTID. */
1238 thread_db_get_thread_local_address (ptid_t ptid
,
1242 if (is_thread (ptid
))
1246 struct thread_info
*thread_info
;
1248 /* glibc doesn't provide the needed interface. */
1249 if (!td_thr_tls_get_addr_p
)
1250 throw_error (TLS_NO_LIBRARY_SUPPORT_ERROR
,
1251 _("No TLS library support"));
1253 /* Caller should have verified that lm != 0. */
1254 gdb_assert (lm
!= 0);
1256 /* Get info about the thread. */
1257 thread_info
= find_thread_pid (ptid
);
1258 thread_db_map_id2thr (thread_info
, 1);
1260 /* Finally, get the address of the variable. */
1261 err
= td_thr_tls_get_addr_p (&thread_info
->private->th
, (void *) lm
,
1264 #ifdef THREAD_DB_HAS_TD_NOTALLOC
1265 /* The memory hasn't been allocated, yet. */
1266 if (err
== TD_NOTALLOC
)
1267 /* Now, if libthread_db provided the initialization image's
1268 address, we *could* try to build a non-lvalue value from
1269 the initialization image. */
1270 throw_error (TLS_NOT_ALLOCATED_YET_ERROR
,
1271 _("TLS not allocated yet"));
1274 /* Something else went wrong. */
1276 throw_error (TLS_GENERIC_ERROR
,
1277 (("%s")), thread_db_err_str (err
));
1279 /* Cast assuming host == target. Joy. */
1280 return (CORE_ADDR
) address
;
1283 if (target_beneath
->to_get_thread_local_address
)
1284 return target_beneath
->to_get_thread_local_address (ptid
, lm
, offset
);
1286 throw_error (TLS_GENERIC_ERROR
,
1287 _("TLS not supported on this target"));
1291 init_thread_db_ops (void)
1293 thread_db_ops
.to_shortname
= "multi-thread";
1294 thread_db_ops
.to_longname
= "multi-threaded child process.";
1295 thread_db_ops
.to_doc
= "Threads and pthreads support.";
1296 thread_db_ops
.to_attach
= thread_db_attach
;
1297 thread_db_ops
.to_detach
= thread_db_detach
;
1298 thread_db_ops
.to_resume
= thread_db_resume
;
1299 thread_db_ops
.to_wait
= thread_db_wait
;
1300 thread_db_ops
.to_fetch_registers
= thread_db_fetch_registers
;
1301 thread_db_ops
.to_store_registers
= thread_db_store_registers
;
1302 thread_db_ops
.to_xfer_partial
= thread_db_xfer_partial
;
1303 thread_db_ops
.to_kill
= thread_db_kill
;
1304 thread_db_ops
.to_create_inferior
= thread_db_create_inferior
;
1305 thread_db_ops
.to_post_startup_inferior
= thread_db_post_startup_inferior
;
1306 thread_db_ops
.to_mourn_inferior
= thread_db_mourn_inferior
;
1307 thread_db_ops
.to_thread_alive
= thread_db_thread_alive
;
1308 thread_db_ops
.to_find_new_threads
= thread_db_find_new_threads
;
1309 thread_db_ops
.to_pid_to_str
= thread_db_pid_to_str
;
1310 thread_db_ops
.to_stratum
= thread_stratum
;
1311 thread_db_ops
.to_has_thread_control
= tc_schedlock
;
1312 thread_db_ops
.to_get_thread_local_address
1313 = thread_db_get_thread_local_address
;
1314 thread_db_ops
.to_magic
= OPS_MAGIC
;
1318 _initialize_thread_db (void)
1320 /* Only initialize the module if we can load libthread_db. */
1321 if (thread_db_load ())
1323 init_thread_db_ops ();
1324 add_target (&thread_db_ops
);
1326 /* Add ourselves to objfile event chain. */
1327 target_new_objfile_chain
= deprecated_target_new_objfile_hook
;
1328 deprecated_target_new_objfile_hook
= thread_db_new_objfile
;