1 /* libthread_db assisted debugging support, generic parts.
2 Copyright 1999, 2000, 2001 Free Software Foundation, Inc.
4 This file is part of GDB.
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 59 Temple Place - Suite 330,
19 Boston, MA 02111-1307, USA. */
23 #include "gdb_assert.h"
25 #include "gdb_proc_service.h"
26 #include "gdb_thread_db.h"
29 #include "gdbthread.h"
35 #include "solib-svr4.h"
37 #ifndef LIBTHREAD_DB_SO
38 #define LIBTHREAD_DB_SO "libthread_db.so.1"
41 /* If we're running on GNU/Linux, we must explicitly attach to any new
44 /* FIXME: There is certainly some room for improvements:
46 - Bypass libthread_db when fetching or storing registers for
47 threads bound to a LWP. */
49 /* This module's target vector. */
50 static struct target_ops thread_db_ops
;
52 /* The target vector that we call for things this module can't handle. */
53 static struct target_ops
*target_beneath
;
55 /* Pointer to the next function on the objfile event chain. */
56 static void (*target_new_objfile_chain
) (struct objfile
*objfile
);
58 /* Non-zero if we're using this module's target vector. */
59 static int using_thread_db
;
61 /* Non-zero if we have to keep this module's target vector active
63 static int keep_thread_db
;
65 /* Non-zero if we have determined the signals used by the threads
67 static int thread_signals
;
68 static sigset_t thread_stop_set
;
69 static sigset_t thread_print_set
;
71 /* Structure that identifies the child process for the
72 <proc_service.h> interface. */
73 static struct ps_prochandle proc_handle
;
75 /* Connection to the libthread_db library. */
76 static td_thragent_t
*thread_agent
;
78 /* Pointers to the libthread_db functions. */
80 static td_err_e (*td_init_p
) (void);
82 static td_err_e (*td_ta_new_p
) (struct ps_prochandle
*ps
, td_thragent_t
**ta
);
83 static td_err_e (*td_ta_map_id2thr_p
) (const td_thragent_t
*ta
, thread_t pt
,
84 td_thrhandle_t
*__th
);
85 static td_err_e (*td_ta_map_lwp2thr_p
) (const td_thragent_t
*ta
, lwpid_t lwpid
,
87 static td_err_e (*td_ta_thr_iter_p
) (const td_thragent_t
*ta
,
88 td_thr_iter_f
*callback
,
89 void *cbdata_p
, td_thr_state_e state
,
90 int ti_pri
, sigset_t
*ti_sigmask_p
,
91 unsigned int ti_user_flags
);
92 static td_err_e (*td_ta_event_addr_p
) (const td_thragent_t
*ta
,
93 td_event_e event
, td_notify_t
*ptr
);
94 static td_err_e (*td_ta_set_event_p
) (const td_thragent_t
*ta
,
95 td_thr_events_t
*event
);
96 static td_err_e (*td_ta_event_getmsg_p
) (const td_thragent_t
*ta
,
99 static td_err_e (*td_thr_validate_p
) (const td_thrhandle_t
*th
);
100 static td_err_e (*td_thr_get_info_p
) (const td_thrhandle_t
*th
,
101 td_thrinfo_t
*infop
);
102 static td_err_e (*td_thr_getfpregs_p
) (const td_thrhandle_t
*th
,
103 gdb_prfpregset_t
*regset
);
104 static td_err_e (*td_thr_getgregs_p
) (const td_thrhandle_t
*th
,
106 static td_err_e (*td_thr_setfpregs_p
) (const td_thrhandle_t
*th
,
107 const gdb_prfpregset_t
*fpregs
);
108 static td_err_e (*td_thr_setgregs_p
) (const td_thrhandle_t
*th
,
110 static td_err_e (*td_thr_event_enable_p
) (const td_thrhandle_t
*th
, int event
);
112 static td_err_e (*td_thr_tls_get_addr_p
) (const td_thrhandle_t
*th
,
117 /* Location of the thread creation event breakpoint. The code at this
118 location in the child process will be called by the pthread library
119 whenever a new thread is created. By setting a special breakpoint
120 at this location, GDB can detect when a new thread is created. We
121 obtain this location via the td_ta_event_addr call. */
122 static CORE_ADDR td_create_bp_addr
;
124 /* Location of the thread death event breakpoint. */
125 static CORE_ADDR td_death_bp_addr
;
127 /* Prototypes for local functions. */
128 static void thread_db_find_new_threads (void);
129 static void attach_thread (ptid_t ptid
, const td_thrhandle_t
*th_p
,
130 const td_thrinfo_t
*ti_p
, int verbose
);
133 /* Building process ids. */
135 #define GET_PID(ptid) ptid_get_pid (ptid)
136 #define GET_LWP(ptid) ptid_get_lwp (ptid)
137 #define GET_THREAD(ptid) ptid_get_tid (ptid)
139 #define is_lwp(ptid) (GET_LWP (ptid) != 0)
140 #define is_thread(ptid) (GET_THREAD (ptid) != 0)
142 #define BUILD_LWP(lwp, pid) ptid_build (pid, lwp, 0)
143 #define BUILD_THREAD(tid, pid) ptid_build (pid, 0, tid)
146 /* Use "struct private_thread_info" to cache thread state. This is
147 a substantial optimization. */
149 struct private_thread_info
151 /* Cached thread state. */
152 unsigned int th_valid
: 1;
153 unsigned int ti_valid
: 1;
161 thread_db_err_str (td_err_e err
)
168 return "generic 'call succeeded'";
170 return "generic error";
172 return "no thread to satisfy query";
174 return "no sync handle to satisfy query";
176 return "no LWP to satisfy query";
178 return "invalid process handle";
180 return "invalid thread handle";
182 return "invalid synchronization handle";
184 return "invalid thread agent";
186 return "invalid key";
188 return "no event message for getmsg";
190 return "FPU register set not available";
192 return "application not linked with libthread";
194 return "requested event is not supported";
196 return "capability not available";
198 return "debugger service failed";
200 return "operation not applicable to";
202 return "no thread-specific data for this thread";
204 return "malloc failed";
206 return "only part of register set was written/read";
208 return "X register set not available for this thread";
210 snprintf (buf
, sizeof (buf
), "unknown thread_db error '%d'", err
);
216 thread_db_state_str (td_thr_state_e state
)
223 return "stopped by debugger";
232 case TD_THR_STOPPED_ASLEEP
:
233 return "stopped by debugger AND blocked";
235 snprintf (buf
, sizeof (buf
), "unknown thread_db state %d", state
);
240 /* A callback function for td_ta_thr_iter, which we use to map all
243 THP is a handle to the current thread; if INFOP is not NULL, the
244 struct thread_info associated with this thread is returned in
248 thread_get_info_callback (const td_thrhandle_t
*thp
, void *infop
)
252 struct thread_info
*thread_info
;
255 err
= td_thr_get_info_p (thp
, &ti
);
257 error ("thread_get_info_callback: cannot get thread info: %s",
258 thread_db_err_str (err
));
260 /* Fill the cache. */
261 thread_ptid
= BUILD_THREAD (ti
.ti_tid
, GET_PID (inferior_ptid
));
262 thread_info
= find_thread_pid (thread_ptid
);
264 if (thread_info
== NULL
)
266 /* New thread. Attach to it now (why wait?). */
267 attach_thread (thread_ptid
, thp
, &ti
, 1);
268 thread_info
= find_thread_pid (thread_ptid
);
269 gdb_assert (thread_info
!= NULL
);
272 memcpy (&thread_info
->private->th
, thp
, sizeof (*thp
));
273 thread_info
->private->th_valid
= 1;
274 memcpy (&thread_info
->private->ti
, &ti
, sizeof (ti
));
275 thread_info
->private->ti_valid
= 1;
278 *(struct thread_info
**) infop
= thread_info
;
283 /* Accessor functions for the thread_db information, with caching. */
286 thread_db_map_id2thr (struct thread_info
*thread_info
, int fatal
)
290 if (thread_info
->private->th_valid
)
293 err
= td_ta_map_id2thr_p (thread_agent
, GET_THREAD (thread_info
->ptid
),
294 &thread_info
->private->th
);
298 error ("Cannot find thread %ld: %s",
299 (long) GET_THREAD (thread_info
->ptid
), thread_db_err_str (err
));
302 thread_info
->private->th_valid
= 1;
305 static td_thrinfo_t
*
306 thread_db_get_info (struct thread_info
*thread_info
)
310 if (thread_info
->private->ti_valid
)
311 return &thread_info
->private->ti
;
313 if (! thread_info
->private->th_valid
)
314 thread_db_map_id2thr (thread_info
, 1);
316 err
= td_thr_get_info_p (&thread_info
->private->th
, &thread_info
->private->ti
);
318 error ("thread_db_get_info: cannot get thread info: %s",
319 thread_db_err_str (err
));
321 thread_info
->private->ti_valid
= 1;
322 return &thread_info
->private->ti
;
325 /* Convert between user-level thread ids and LWP ids. */
328 thread_from_lwp (ptid_t ptid
)
332 struct thread_info
*thread_info
;
335 if (GET_LWP (ptid
) == 0)
336 ptid
= BUILD_LWP (GET_PID (ptid
), GET_PID (ptid
));
338 gdb_assert (is_lwp (ptid
));
340 err
= td_ta_map_lwp2thr_p (thread_agent
, GET_LWP (ptid
), &th
);
342 error ("Cannot find user-level thread for LWP %ld: %s",
343 GET_LWP (ptid
), thread_db_err_str (err
));
346 thread_get_info_callback (&th
, &thread_info
);
347 gdb_assert (thread_info
&& thread_info
->private->ti_valid
);
349 return BUILD_THREAD (thread_info
->private->ti
.ti_tid
, GET_PID (ptid
));
353 lwp_from_thread (ptid_t ptid
)
355 struct thread_info
*thread_info
;
358 if (!is_thread (ptid
))
361 thread_info
= find_thread_pid (ptid
);
362 thread_db_get_info (thread_info
);
364 return BUILD_LWP (thread_info
->private->ti
.ti_lid
, GET_PID (ptid
));
369 thread_db_init (struct target_ops
*target
)
371 target_beneath
= target
;
375 thread_db_load (void)
380 handle
= dlopen (LIBTHREAD_DB_SO
, RTLD_NOW
);
383 fprintf_filtered (gdb_stderr
, "\n\ndlopen failed on '%s' - %s\n",
384 LIBTHREAD_DB_SO
, dlerror ());
385 fprintf_filtered (gdb_stderr
,
386 "GDB will not be able to debug pthreads.\n\n");
390 /* Initialize pointers to the dynamic library functions we will use.
391 Essential functions first. */
393 td_init_p
= dlsym (handle
, "td_init");
394 if (td_init_p
== NULL
)
397 td_ta_new_p
= dlsym (handle
, "td_ta_new");
398 if (td_ta_new_p
== NULL
)
401 td_ta_map_id2thr_p
= dlsym (handle
, "td_ta_map_id2thr");
402 if (td_ta_map_id2thr_p
== NULL
)
405 td_ta_map_lwp2thr_p
= dlsym (handle
, "td_ta_map_lwp2thr");
406 if (td_ta_map_lwp2thr_p
== NULL
)
409 td_ta_thr_iter_p
= dlsym (handle
, "td_ta_thr_iter");
410 if (td_ta_thr_iter_p
== NULL
)
413 td_thr_validate_p
= dlsym (handle
, "td_thr_validate");
414 if (td_thr_validate_p
== NULL
)
417 td_thr_get_info_p
= dlsym (handle
, "td_thr_get_info");
418 if (td_thr_get_info_p
== NULL
)
421 td_thr_getfpregs_p
= dlsym (handle
, "td_thr_getfpregs");
422 if (td_thr_getfpregs_p
== NULL
)
425 td_thr_getgregs_p
= dlsym (handle
, "td_thr_getgregs");
426 if (td_thr_getgregs_p
== NULL
)
429 td_thr_setfpregs_p
= dlsym (handle
, "td_thr_setfpregs");
430 if (td_thr_setfpregs_p
== NULL
)
433 td_thr_setgregs_p
= dlsym (handle
, "td_thr_setgregs");
434 if (td_thr_setgregs_p
== NULL
)
437 /* Initialize the library. */
441 warning ("Cannot initialize libthread_db: %s", thread_db_err_str (err
));
445 /* These are not essential. */
446 td_ta_event_addr_p
= dlsym (handle
, "td_ta_event_addr");
447 td_ta_set_event_p
= dlsym (handle
, "td_ta_set_event");
448 td_ta_event_getmsg_p
= dlsym (handle
, "td_ta_event_getmsg");
449 td_thr_event_enable_p
= dlsym (handle
, "td_thr_event_enable");
450 td_thr_tls_get_addr_p
= dlsym (handle
, "td_thr_tls_get_addr");
456 enable_thread_event_reporting (void)
458 td_thr_events_t events
;
462 /* We cannot use the thread event reporting facility if these
463 functions aren't available. */
464 if (td_ta_event_addr_p
== NULL
|| td_ta_set_event_p
== NULL
465 || td_ta_event_getmsg_p
== NULL
|| td_thr_event_enable_p
== NULL
)
468 /* Set the process wide mask saying which events we're interested in. */
469 td_event_emptyset (&events
);
470 td_event_addset (&events
, TD_CREATE
);
472 /* FIXME: kettenis/2000-04-23: The event reporting facility is
473 broken for TD_DEATH events in glibc 2.1.3, so don't enable it for
475 td_event_addset (&events
, TD_DEATH
);
478 err
= td_ta_set_event_p (thread_agent
, &events
);
481 warning ("Unable to set global thread event mask: %s",
482 thread_db_err_str (err
));
486 /* Delete previous thread event breakpoints, if any. */
487 remove_thread_event_breakpoints ();
489 /* Get address for thread creation breakpoint. */
490 err
= td_ta_event_addr_p (thread_agent
, TD_CREATE
, ¬ify
);
493 warning ("Unable to get location for thread creation breakpoint: %s",
494 thread_db_err_str (err
));
498 /* Set up the breakpoint. */
499 td_create_bp_addr
= (CORE_ADDR
) notify
.u
.bptaddr
;
500 create_thread_event_breakpoint (td_create_bp_addr
);
502 /* Get address for thread death breakpoint. */
503 err
= td_ta_event_addr_p (thread_agent
, TD_DEATH
, ¬ify
);
506 warning ("Unable to get location for thread death breakpoint: %s",
507 thread_db_err_str (err
));
511 /* Set up the breakpoint. */
512 td_death_bp_addr
= (CORE_ADDR
) notify
.u
.bptaddr
;
513 create_thread_event_breakpoint (td_death_bp_addr
);
517 disable_thread_event_reporting (void)
519 td_thr_events_t events
;
521 /* Set the process wide mask saying we aren't interested in any
523 td_event_emptyset (&events
);
524 td_ta_set_event_p (thread_agent
, &events
);
526 /* Delete thread event breakpoints, if any. */
527 remove_thread_event_breakpoints ();
528 td_create_bp_addr
= 0;
529 td_death_bp_addr
= 0;
533 check_thread_signals (void)
535 #ifdef GET_THREAD_SIGNALS
541 GET_THREAD_SIGNALS (&mask
);
542 sigemptyset (&thread_stop_set
);
543 sigemptyset (&thread_print_set
);
545 for (i
= 1; i
< NSIG
; i
++)
547 if (sigismember (&mask
, i
))
549 if (signal_stop_update (target_signal_from_host (i
), 0))
550 sigaddset (&thread_stop_set
, i
);
551 if (signal_print_update (target_signal_from_host (i
), 0))
552 sigaddset (&thread_print_set
, i
);
561 disable_thread_signals (void)
563 #ifdef GET_THREAD_SIGNALS
568 for (i
= 1; i
< NSIG
; i
++)
570 if (sigismember (&thread_stop_set
, i
))
571 signal_stop_update (target_signal_from_host (i
), 1);
572 if (sigismember (&thread_print_set
, i
))
573 signal_print_update (target_signal_from_host (i
), 1);
582 thread_db_new_objfile (struct objfile
*objfile
)
586 /* Don't attempt to use thread_db on targets which can not run
588 if (objfile
== NULL
|| !target_has_execution
)
590 /* All symbols have been discarded. If the thread_db target is
591 active, deactivate it now. */
594 gdb_assert (proc_handle
.pid
== 0);
595 unpush_target (&thread_db_ops
);
605 /* Nothing to do. The thread library was already detected and the
606 target vector was already activated. */
609 /* Initialize the structure that identifies the child process. Note
610 that at this point there is no guarantee that we actually have a
612 proc_handle
.pid
= GET_PID (inferior_ptid
);
614 /* Now attempt to open a connection to the thread library. */
615 err
= td_ta_new_p (&proc_handle
, &thread_agent
);
619 /* No thread library was detected. */
623 /* The thread library was detected. Activate the thread_db target. */
624 push_target (&thread_db_ops
);
627 /* If the thread library was detected in the main symbol file
628 itself, we assume that the program was statically linked
629 against the thread library and well have to keep this
630 module's target vector activated until forever... Well, at
631 least until all symbols have been discarded anyway (see
633 if (objfile
== symfile_objfile
)
635 gdb_assert (proc_handle
.pid
== 0);
639 /* We can only poke around if there actually is a child process.
640 If there is no child process alive, postpone the steps below
641 until one has been created. */
642 if (proc_handle
.pid
!= 0)
644 enable_thread_event_reporting ();
645 thread_db_find_new_threads ();
650 warning ("Cannot initialize thread debugging library: %s",
651 thread_db_err_str (err
));
656 if (target_new_objfile_chain
)
657 target_new_objfile_chain (objfile
);
661 attach_thread (ptid_t ptid
, const td_thrhandle_t
*th_p
,
662 const td_thrinfo_t
*ti_p
, int verbose
)
664 struct thread_info
*tp
;
667 check_thread_signals ();
669 /* Add the thread to GDB's thread list. */
670 tp
= add_thread (ptid
);
671 tp
->private = xmalloc (sizeof (struct private_thread_info
));
672 memset (tp
->private, 0, sizeof (struct private_thread_info
));
675 printf_unfiltered ("[New %s]\n", target_pid_to_str (ptid
));
677 if (ti_p
->ti_state
== TD_THR_UNKNOWN
|| ti_p
->ti_state
== TD_THR_ZOMBIE
)
678 return; /* A zombie thread -- do not attach. */
680 /* Under GNU/Linux, we have to attach to each and every thread. */
682 ATTACH_LWP (BUILD_LWP (ti_p
->ti_lid
, GET_PID (ptid
)), 0);
685 /* Enable thread event reporting for this thread. */
686 err
= td_thr_event_enable_p (th_p
, 1);
688 error ("Cannot enable thread event reporting for %s: %s",
689 target_pid_to_str (ptid
), thread_db_err_str (err
));
693 thread_db_attach (char *args
, int from_tty
)
695 target_beneath
->to_attach (args
, from_tty
);
697 /* Destroy thread info; it's no longer valid. */
700 /* The child process is now the actual multi-threaded
701 program. Snatch its process ID... */
702 proc_handle
.pid
= GET_PID (inferior_ptid
);
704 /* ...and perform the remaining initialization steps. */
705 enable_thread_event_reporting ();
706 thread_db_find_new_threads();
710 detach_thread (ptid_t ptid
, int verbose
)
713 printf_unfiltered ("[%s exited]\n", target_pid_to_str (ptid
));
717 thread_db_detach (char *args
, int from_tty
)
719 disable_thread_event_reporting ();
721 /* There's no need to save & restore inferior_ptid here, since the
722 inferior is supposed to be survive this function call. */
723 inferior_ptid
= lwp_from_thread (inferior_ptid
);
725 /* Forget about the child's process ID. We shouldn't need it
729 target_beneath
->to_detach (args
, from_tty
);
733 clear_lwpid_callback (struct thread_info
*thread
, void *dummy
)
735 /* If we know that our thread implementation is 1-to-1, we could save
736 a certain amount of information; it's not clear how much, so we
737 are always conservative. */
739 thread
->private->th_valid
= 0;
740 thread
->private->ti_valid
= 0;
746 thread_db_resume (ptid_t ptid
, int step
, enum target_signal signo
)
748 struct cleanup
*old_chain
= save_inferior_ptid ();
750 if (GET_PID (ptid
) == -1)
751 inferior_ptid
= lwp_from_thread (inferior_ptid
);
752 else if (is_thread (ptid
))
753 ptid
= lwp_from_thread (ptid
);
755 /* Clear cached data which may not be valid after the resume. */
756 iterate_over_threads (clear_lwpid_callback
, NULL
);
758 target_beneath
->to_resume (ptid
, step
, signo
);
760 do_cleanups (old_chain
);
763 /* Check if PID is currently stopped at the location of a thread event
764 breakpoint location. If it is, read the event message and act upon
768 check_event (ptid_t ptid
)
775 /* Bail out early if we're not at a thread event breakpoint. */
776 stop_pc
= read_pc_pid (ptid
) - DECR_PC_AFTER_BREAK
;
777 if (stop_pc
!= td_create_bp_addr
&& stop_pc
!= td_death_bp_addr
)
780 err
= td_ta_event_getmsg_p (thread_agent
, &msg
);
786 error ("Cannot get thread event message: %s", thread_db_err_str (err
));
789 err
= td_thr_get_info_p (msg
.th_p
, &ti
);
791 error ("check_event: cannot get thread info: %s",
792 thread_db_err_str (err
));
794 ptid
= BUILD_THREAD (ti
.ti_tid
, GET_PID (ptid
));
800 /* FIXME: kettenis/2000-08-26: Since we use td_ta_event_getmsg,
801 there is no guarantee that the breakpoint will match the
802 event. Should we use td_thr_event_getmsg instead? */
804 if (stop_pc
!= td_create_bp_addr
)
805 error ("Thread creation event doesn't match breakpoint.");
808 /* We may already know about this thread, for instance when the
809 user has issued the `info threads' command before the SIGTRAP
810 for hitting the thread creation breakpoint was reported. */
811 if (!in_thread_list (ptid
))
812 attach_thread (ptid
, msg
.th_p
, &ti
, 1);
817 /* FIXME: See TD_CREATE. */
819 if (stop_pc
!= td_death_bp_addr
)
820 error ("Thread death event doesn't match breakpoint.");
823 if (!in_thread_list (ptid
))
824 error ("Spurious thread death event.");
826 detach_thread (ptid
, 1);
830 error ("Spurious thread event.");
835 thread_db_wait (ptid_t ptid
, struct target_waitstatus
*ourstatus
)
837 extern ptid_t trap_ptid
;
839 if (GET_PID (ptid
) != -1 && is_thread (ptid
))
840 ptid
= lwp_from_thread (ptid
);
842 ptid
= target_beneath
->to_wait (ptid
, ourstatus
);
844 if (proc_handle
.pid
== 0)
845 /* The current child process isn't the actual multi-threaded
846 program yet, so don't try to do any special thread-specific
847 post-processing and bail out early. */
850 if (ourstatus
->kind
== TARGET_WAITKIND_EXITED
)
851 return pid_to_ptid (-1);
853 if (ourstatus
->kind
== TARGET_WAITKIND_STOPPED
854 && ourstatus
->value
.sig
== TARGET_SIGNAL_TRAP
)
855 /* Check for a thread event. */
858 if (!ptid_equal (trap_ptid
, null_ptid
))
859 trap_ptid
= thread_from_lwp (trap_ptid
);
861 return thread_from_lwp (ptid
);
865 thread_db_xfer_memory (CORE_ADDR memaddr
, char *myaddr
, int len
, int write
,
866 struct mem_attrib
*attrib
,
867 struct target_ops
*target
)
869 struct cleanup
*old_chain
= save_inferior_ptid ();
872 if (is_thread (inferior_ptid
))
874 /* FIXME: This seems to be necessary to make sure breakpoints
876 if (!target_thread_alive (inferior_ptid
))
877 inferior_ptid
= pid_to_ptid (GET_PID (inferior_ptid
));
879 inferior_ptid
= lwp_from_thread (inferior_ptid
);
882 xfer
= target_beneath
->to_xfer_memory (memaddr
, myaddr
, len
, write
, attrib
, target
);
884 do_cleanups (old_chain
);
889 thread_db_fetch_registers (int regno
)
891 struct thread_info
*thread_info
;
893 gdb_prfpregset_t fpregset
;
896 if (!is_thread (inferior_ptid
))
898 /* Pass the request to the target beneath us. */
899 target_beneath
->to_fetch_registers (regno
);
903 thread_info
= find_thread_pid (inferior_ptid
);
904 thread_db_map_id2thr (thread_info
, 1);
906 err
= td_thr_getgregs_p (&thread_info
->private->th
, gregset
);
908 error ("Cannot fetch general-purpose registers for thread %ld: %s",
909 (long) GET_THREAD (inferior_ptid
), thread_db_err_str (err
));
911 err
= td_thr_getfpregs_p (&thread_info
->private->th
, &fpregset
);
913 error ("Cannot get floating-point registers for thread %ld: %s",
914 (long) GET_THREAD (inferior_ptid
), thread_db_err_str (err
));
916 /* Note that we must call supply_gregset after calling the thread_db
917 routines because the thread_db routines call ps_lgetgregs and
918 friends which clobber GDB's register cache. */
919 supply_gregset ((gdb_gregset_t
*) gregset
);
920 supply_fpregset (&fpregset
);
924 thread_db_store_registers (int regno
)
927 gdb_prfpregset_t fpregset
;
929 struct thread_info
*thread_info
;
931 if (!is_thread (inferior_ptid
))
933 /* Pass the request to the target beneath us. */
934 target_beneath
->to_store_registers (regno
);
938 thread_info
= find_thread_pid (inferior_ptid
);
939 thread_db_map_id2thr (thread_info
, 1);
943 char raw
[MAX_REGISTER_RAW_SIZE
];
945 deprecated_read_register_gen (regno
, raw
);
946 thread_db_fetch_registers (-1);
947 supply_register (regno
, raw
);
950 fill_gregset ((gdb_gregset_t
*) gregset
, -1);
951 fill_fpregset (&fpregset
, -1);
953 err
= td_thr_setgregs_p (&thread_info
->private->th
, gregset
);
955 error ("Cannot store general-purpose registers for thread %ld: %s",
956 (long) GET_THREAD (inferior_ptid
), thread_db_err_str (err
));
957 err
= td_thr_setfpregs_p (&thread_info
->private->th
, &fpregset
);
959 error ("Cannot store floating-point registers for thread %ld: %s",
960 (long) GET_THREAD (inferior_ptid
), thread_db_err_str (err
));
964 thread_db_kill (void)
966 /* There's no need to save & restore inferior_ptid here, since the
967 inferior isn't supposed to survive this function call. */
968 inferior_ptid
= lwp_from_thread (inferior_ptid
);
969 target_beneath
->to_kill ();
973 thread_db_create_inferior (char *exec_file
, char *allargs
, char **env
)
977 unpush_target (&thread_db_ops
);
981 target_beneath
->to_create_inferior (exec_file
, allargs
, env
);
985 thread_db_post_startup_inferior (ptid_t ptid
)
987 if (proc_handle
.pid
== 0)
989 /* The child process is now the actual multi-threaded
990 program. Snatch its process ID... */
991 proc_handle
.pid
= GET_PID (ptid
);
993 /* ...and perform the remaining initialization steps. */
994 enable_thread_event_reporting ();
995 thread_db_find_new_threads ();
1000 thread_db_mourn_inferior (void)
1002 remove_thread_event_breakpoints ();
1004 /* Forget about the child's process ID. We shouldn't need it
1006 proc_handle
.pid
= 0;
1008 target_beneath
->to_mourn_inferior ();
1012 thread_db_thread_alive (ptid_t ptid
)
1017 if (is_thread (ptid
))
1019 struct thread_info
*thread_info
;
1020 thread_info
= find_thread_pid (ptid
);
1022 thread_db_map_id2thr (thread_info
, 0);
1023 if (! thread_info
->private->th_valid
)
1026 err
= td_thr_validate_p (&thread_info
->private->th
);
1030 if (! thread_info
->private->ti_valid
)
1032 err
= td_thr_get_info_p (&thread_info
->private->th
, &thread_info
->private->ti
);
1035 thread_info
->private->ti_valid
= 1;
1038 if (thread_info
->private->ti
.ti_state
== TD_THR_UNKNOWN
1039 || thread_info
->private->ti
.ti_state
== TD_THR_ZOMBIE
)
1040 return 0; /* A zombie thread. */
1045 if (target_beneath
->to_thread_alive
)
1046 return target_beneath
->to_thread_alive (ptid
);
1052 find_new_threads_callback (const td_thrhandle_t
*th_p
, void *data
)
1058 err
= td_thr_get_info_p (th_p
, &ti
);
1060 error ("find_new_threads_callback: cannot get thread info: %s",
1061 thread_db_err_str (err
));
1063 if (ti
.ti_state
== TD_THR_UNKNOWN
|| ti
.ti_state
== TD_THR_ZOMBIE
)
1064 return 0; /* A zombie -- ignore. */
1066 ptid
= BUILD_THREAD (ti
.ti_tid
, GET_PID (inferior_ptid
));
1068 if (!in_thread_list (ptid
))
1069 attach_thread (ptid
, th_p
, &ti
, 1);
1075 thread_db_find_new_threads (void)
1079 /* Iterate over all user-space threads to discover new threads. */
1080 err
= td_ta_thr_iter_p (thread_agent
, find_new_threads_callback
, NULL
,
1081 TD_THR_ANY_STATE
, TD_THR_LOWEST_PRIORITY
,
1082 TD_SIGNO_MASK
, TD_THR_ANY_USER_FLAGS
);
1084 error ("Cannot find new threads: %s", thread_db_err_str (err
));
1088 thread_db_pid_to_str (ptid_t ptid
)
1090 if (is_thread (ptid
))
1092 static char buf
[64];
1095 struct thread_info
*thread_info
;
1097 thread_info
= find_thread_pid (ptid
);
1098 thread_db_map_id2thr (thread_info
, 0);
1099 if (! thread_info
->private->th_valid
)
1101 snprintf (buf
, sizeof (buf
), "Thread %ld (Missing)", GET_THREAD (ptid
));
1105 ti_p
= thread_db_get_info (thread_info
);
1107 if (ti_p
->ti_state
== TD_THR_ACTIVE
&& ti_p
->ti_lid
!= 0)
1109 snprintf (buf
, sizeof (buf
), "Thread %ld (LWP %d)",
1110 (long) ti_p
->ti_tid
, ti_p
->ti_lid
);
1114 snprintf (buf
, sizeof (buf
), "Thread %ld (%s)",
1115 (long) ti_p
->ti_tid
, thread_db_state_str (ti_p
->ti_state
));
1121 if (target_beneath
->to_pid_to_str (ptid
))
1122 return target_beneath
->to_pid_to_str (ptid
);
1124 return normal_pid_to_str (ptid
);
1127 /* Get the address of the thread local variable in OBJFILE which is
1128 stored at OFFSET within the thread local storage for thread PTID. */
1131 thread_db_get_thread_local_address (ptid_t ptid
, struct objfile
*objfile
,
1134 if (is_thread (ptid
))
1136 int objfile_is_library
= (objfile
->flags
& OBJF_SHARED
);
1140 struct thread_info
*thread_info
;
1142 /* glibc doesn't provide the needed interface. */
1143 if (! td_thr_tls_get_addr_p
)
1144 error ("Cannot find thread-local variables in this thread library.");
1146 /* Get the address of the link map for this objfile. */
1147 lm
= svr4_fetch_objfile_link_map (objfile
);
1149 /* Whoops, we couldn't find one. Bail out. */
1152 if (objfile_is_library
)
1153 error ("Cannot find shared library `%s' link_map in dynamic"
1154 " linker's module list", objfile
->name
);
1156 error ("Cannot find executable file `%s' link_map in dynamic"
1157 " linker's module list", objfile
->name
);
1160 /* Get info about the thread. */
1161 thread_info
= find_thread_pid (ptid
);
1162 thread_db_map_id2thr (thread_info
, 1);
1164 /* Finally, get the address of the variable. */
1165 err
= td_thr_tls_get_addr_p (&thread_info
->private->th
, (void *) lm
,
1168 #ifdef THREAD_DB_HAS_TD_NOTALLOC
1169 /* The memory hasn't been allocated, yet. */
1170 if (err
== TD_NOTALLOC
)
1172 /* Now, if libthread_db provided the initialization image's
1173 address, we *could* try to build a non-lvalue value from
1174 the initialization image. */
1175 if (objfile_is_library
)
1176 error ("The inferior has not yet allocated storage for"
1177 " thread-local variables in\n"
1178 "the shared library `%s'\n"
1179 "for the thread %ld",
1180 objfile
->name
, (long) GET_THREAD (ptid
));
1182 error ("The inferior has not yet allocated storage for"
1183 " thread-local variables in\n"
1184 "the executable `%s'\n"
1185 "for the thread %ld",
1186 objfile
->name
, (long) GET_THREAD (ptid
));
1190 /* Something else went wrong. */
1193 if (objfile_is_library
)
1194 error ("Cannot find thread-local storage for thread %ld, "
1195 "shared library %s:\n%s",
1196 (long) GET_THREAD (ptid
),
1198 thread_db_err_str (err
));
1200 error ("Cannot find thread-local storage for thread %ld, "
1201 "executable file %s:\n%s",
1202 (long) GET_THREAD (ptid
),
1204 thread_db_err_str (err
));
1207 /* Cast assuming host == target. Joy. */
1208 return (CORE_ADDR
) address
;
1211 if (target_beneath
->to_get_thread_local_address
)
1212 return target_beneath
->to_get_thread_local_address (ptid
, objfile
, offset
);
1214 error ("Cannot find thread-local values on this target.");
1218 init_thread_db_ops (void)
1220 thread_db_ops
.to_shortname
= "multi-thread";
1221 thread_db_ops
.to_longname
= "multi-threaded child process.";
1222 thread_db_ops
.to_doc
= "Threads and pthreads support.";
1223 thread_db_ops
.to_attach
= thread_db_attach
;
1224 thread_db_ops
.to_detach
= thread_db_detach
;
1225 thread_db_ops
.to_resume
= thread_db_resume
;
1226 thread_db_ops
.to_wait
= thread_db_wait
;
1227 thread_db_ops
.to_fetch_registers
= thread_db_fetch_registers
;
1228 thread_db_ops
.to_store_registers
= thread_db_store_registers
;
1229 thread_db_ops
.to_xfer_memory
= thread_db_xfer_memory
;
1230 thread_db_ops
.to_kill
= thread_db_kill
;
1231 thread_db_ops
.to_create_inferior
= thread_db_create_inferior
;
1232 thread_db_ops
.to_post_startup_inferior
= thread_db_post_startup_inferior
;
1233 thread_db_ops
.to_mourn_inferior
= thread_db_mourn_inferior
;
1234 thread_db_ops
.to_thread_alive
= thread_db_thread_alive
;
1235 thread_db_ops
.to_find_new_threads
= thread_db_find_new_threads
;
1236 thread_db_ops
.to_pid_to_str
= thread_db_pid_to_str
;
1237 thread_db_ops
.to_stratum
= thread_stratum
;
1238 thread_db_ops
.to_has_thread_control
= tc_schedlock
;
1239 thread_db_ops
.to_get_thread_local_address
1240 = thread_db_get_thread_local_address
;
1241 thread_db_ops
.to_magic
= OPS_MAGIC
;
1245 _initialize_thread_db (void)
1247 /* Only initialize the module if we can load libthread_db. */
1248 if (thread_db_load ())
1250 init_thread_db_ops ();
1251 add_target (&thread_db_ops
);
1253 /* Add ourselves to objfile event chain. */
1254 target_new_objfile_chain
= target_new_objfile_hook
;
1255 target_new_objfile_hook
= thread_db_new_objfile
;