1 /* libthread_db assisted debugging support, generic parts.
3 Copyright 1999, 2000, 2001, 2003 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 #ifndef LIBTHREAD_DB_SO
39 #define LIBTHREAD_DB_SO "libthread_db.so.1"
42 /* If we're running on GNU/Linux, we must explicitly attach to any new
45 /* FIXME: There is certainly some room for improvements:
47 - Bypass libthread_db when fetching or storing registers for
48 threads bound to a LWP. */
50 /* This module's target vector. */
51 static struct target_ops thread_db_ops
;
53 /* The target vector that we call for things this module can't handle. */
54 static struct target_ops
*target_beneath
;
56 /* Pointer to the next function on the objfile event chain. */
57 static void (*target_new_objfile_chain
) (struct objfile
* objfile
);
59 /* Non-zero if we're using this module's target vector. */
60 static int using_thread_db
;
62 /* Non-zero if we have to keep this module's target vector active
64 static int keep_thread_db
;
66 /* Non-zero if we have determined the signals used by the threads
68 static int thread_signals
;
69 static sigset_t thread_stop_set
;
70 static sigset_t thread_print_set
;
72 /* Structure that identifies the child process for the
73 <proc_service.h> interface. */
74 static struct ps_prochandle proc_handle
;
76 /* Connection to the libthread_db library. */
77 static td_thragent_t
*thread_agent
;
79 /* Pointers to the libthread_db functions. */
81 static td_err_e (*td_init_p
) (void);
83 static td_err_e (*td_ta_new_p
) (struct ps_prochandle
* ps
,
85 static td_err_e (*td_ta_map_id2thr_p
) (const td_thragent_t
*ta
, thread_t pt
,
86 td_thrhandle_t
*__th
);
87 static td_err_e (*td_ta_map_lwp2thr_p
) (const td_thragent_t
*ta
,
88 lwpid_t lwpid
, td_thrhandle_t
*th
);
89 static td_err_e (*td_ta_thr_iter_p
) (const td_thragent_t
*ta
,
90 td_thr_iter_f
*callback
, void *cbdata_p
,
91 td_thr_state_e state
, int ti_pri
,
92 sigset_t
*ti_sigmask_p
,
93 unsigned int ti_user_flags
);
94 static td_err_e (*td_ta_event_addr_p
) (const td_thragent_t
*ta
,
95 td_event_e event
, td_notify_t
*ptr
);
96 static td_err_e (*td_ta_set_event_p
) (const td_thragent_t
*ta
,
97 td_thr_events_t
*event
);
98 static td_err_e (*td_ta_event_getmsg_p
) (const td_thragent_t
*ta
,
101 static td_err_e (*td_thr_validate_p
) (const td_thrhandle_t
*th
);
102 static td_err_e (*td_thr_get_info_p
) (const td_thrhandle_t
*th
,
103 td_thrinfo_t
*infop
);
104 static td_err_e (*td_thr_getfpregs_p
) (const td_thrhandle_t
*th
,
105 gdb_prfpregset_t
*regset
);
106 static td_err_e (*td_thr_getgregs_p
) (const td_thrhandle_t
*th
,
108 static td_err_e (*td_thr_setfpregs_p
) (const td_thrhandle_t
*th
,
109 const gdb_prfpregset_t
*fpregs
);
110 static td_err_e (*td_thr_setgregs_p
) (const td_thrhandle_t
*th
,
112 static td_err_e (*td_thr_event_enable_p
) (const td_thrhandle_t
*th
,
115 static td_err_e (*td_thr_tls_get_addr_p
) (const td_thrhandle_t
*th
,
117 size_t offset
, void **address
);
119 /* Location of the thread creation event breakpoint. The code at this
120 location in the child process will be called by the pthread library
121 whenever a new thread is created. By setting a special breakpoint
122 at this location, GDB can detect when a new thread is created. We
123 obtain this location via the td_ta_event_addr call. */
124 static CORE_ADDR td_create_bp_addr
;
126 /* Location of the thread death event breakpoint. */
127 static CORE_ADDR td_death_bp_addr
;
129 /* Prototypes for local functions. */
130 static void thread_db_find_new_threads (void);
131 static void attach_thread (ptid_t ptid
, const td_thrhandle_t
*th_p
,
132 const td_thrinfo_t
*ti_p
, int verbose
);
135 /* Building process ids. */
137 #define GET_PID(ptid) ptid_get_pid (ptid)
138 #define GET_LWP(ptid) ptid_get_lwp (ptid)
139 #define GET_THREAD(ptid) ptid_get_tid (ptid)
141 #define is_lwp(ptid) (GET_LWP (ptid) != 0)
142 #define is_thread(ptid) (GET_THREAD (ptid) != 0)
144 #define BUILD_LWP(lwp, pid) ptid_build (pid, lwp, 0)
145 #define BUILD_THREAD(tid, pid) ptid_build (pid, 0, tid)
148 /* Use "struct private_thread_info" to cache thread state. This is
149 a substantial optimization. */
151 struct private_thread_info
153 /* Cached thread state. */
154 unsigned int th_valid
:1;
155 unsigned int ti_valid
:1;
163 thread_db_err_str (td_err_e err
)
170 return "generic 'call succeeded'";
172 return "generic error";
174 return "no thread to satisfy query";
176 return "no sync handle to satisfy query";
178 return "no LWP to satisfy query";
180 return "invalid process handle";
182 return "invalid thread handle";
184 return "invalid synchronization handle";
186 return "invalid thread agent";
188 return "invalid key";
190 return "no event message for getmsg";
192 return "FPU register set not available";
194 return "application not linked with libthread";
196 return "requested event is not supported";
198 return "capability not available";
200 return "debugger service failed";
202 return "operation not applicable to";
204 return "no thread-specific data for this thread";
206 return "malloc failed";
208 return "only part of register set was written/read";
210 return "X register set not available for this thread";
212 snprintf (buf
, sizeof (buf
), "unknown thread_db error '%d'", err
);
218 thread_db_state_str (td_thr_state_e state
)
225 return "stopped by debugger";
234 case TD_THR_STOPPED_ASLEEP
:
235 return "stopped by debugger AND blocked";
237 snprintf (buf
, sizeof (buf
), "unknown thread_db state %d", state
);
242 /* A callback function for td_ta_thr_iter, which we use to map all
245 THP is a handle to the current thread; if INFOP is not NULL, the
246 struct thread_info associated with this thread is returned in
250 thread_get_info_callback (const td_thrhandle_t
*thp
, void *infop
)
254 struct thread_info
*thread_info
;
257 err
= td_thr_get_info_p (thp
, &ti
);
259 error ("thread_get_info_callback: cannot get thread info: %s",
260 thread_db_err_str (err
));
262 /* Fill the cache. */
263 thread_ptid
= BUILD_THREAD (ti
.ti_tid
, GET_PID (inferior_ptid
));
264 thread_info
= find_thread_pid (thread_ptid
);
266 if (thread_info
== NULL
)
268 /* New thread. Attach to it now (why wait?). */
269 attach_thread (thread_ptid
, thp
, &ti
, 1);
270 thread_info
= find_thread_pid (thread_ptid
);
271 gdb_assert (thread_info
!= NULL
);
274 memcpy (&thread_info
->private->th
, thp
, sizeof (*thp
));
275 thread_info
->private->th_valid
= 1;
276 memcpy (&thread_info
->private->ti
, &ti
, sizeof (ti
));
277 thread_info
->private->ti_valid
= 1;
280 *(struct thread_info
**) infop
= thread_info
;
285 /* Accessor functions for the thread_db information, with caching. */
288 thread_db_map_id2thr (struct thread_info
*thread_info
, int fatal
)
292 if (thread_info
->private->th_valid
)
295 err
= td_ta_map_id2thr_p (thread_agent
, GET_THREAD (thread_info
->ptid
),
296 &thread_info
->private->th
);
300 error ("Cannot find thread %ld: %s",
301 (long) GET_THREAD (thread_info
->ptid
),
302 thread_db_err_str (err
));
305 thread_info
->private->th_valid
= 1;
308 static td_thrinfo_t
*
309 thread_db_get_info (struct thread_info
*thread_info
)
313 if (thread_info
->private->ti_valid
)
314 return &thread_info
->private->ti
;
316 if (!thread_info
->private->th_valid
)
317 thread_db_map_id2thr (thread_info
, 1);
320 td_thr_get_info_p (&thread_info
->private->th
, &thread_info
->private->ti
);
322 error ("thread_db_get_info: cannot get thread info: %s",
323 thread_db_err_str (err
));
325 thread_info
->private->ti_valid
= 1;
326 return &thread_info
->private->ti
;
329 /* Convert between user-level thread ids and LWP ids. */
332 thread_from_lwp (ptid_t ptid
)
336 struct thread_info
*thread_info
;
339 if (GET_LWP (ptid
) == 0)
340 ptid
= BUILD_LWP (GET_PID (ptid
), GET_PID (ptid
));
342 gdb_assert (is_lwp (ptid
));
344 err
= td_ta_map_lwp2thr_p (thread_agent
, GET_LWP (ptid
), &th
);
346 error ("Cannot find user-level thread for LWP %ld: %s",
347 GET_LWP (ptid
), thread_db_err_str (err
));
350 thread_get_info_callback (&th
, &thread_info
);
351 gdb_assert (thread_info
&& thread_info
->private->ti_valid
);
353 return BUILD_THREAD (thread_info
->private->ti
.ti_tid
, GET_PID (ptid
));
357 lwp_from_thread (ptid_t ptid
)
359 struct thread_info
*thread_info
;
362 if (!is_thread (ptid
))
365 thread_info
= find_thread_pid (ptid
);
366 thread_db_get_info (thread_info
);
368 return BUILD_LWP (thread_info
->private->ti
.ti_lid
, GET_PID (ptid
));
373 thread_db_init (struct target_ops
*target
)
375 target_beneath
= target
;
379 verbose_dlsym (void *handle
, const char *name
)
381 void *sym
= dlsym (handle
, name
);
383 warning ("Symbol \"%s\" not found in libthread_db: %s", name
, dlerror ());
388 thread_db_load (void)
393 handle
= dlopen (LIBTHREAD_DB_SO
, RTLD_NOW
);
396 fprintf_filtered (gdb_stderr
, "\n\ndlopen failed on '%s' - %s\n",
397 LIBTHREAD_DB_SO
, dlerror ());
398 fprintf_filtered (gdb_stderr
,
399 "GDB will not be able to debug pthreads.\n\n");
403 /* Initialize pointers to the dynamic library functions we will use.
404 Essential functions first. */
406 td_init_p
= verbose_dlsym (handle
, "td_init");
407 if (td_init_p
== NULL
)
410 td_ta_new_p
= verbose_dlsym (handle
, "td_ta_new");
411 if (td_ta_new_p
== NULL
)
414 td_ta_map_id2thr_p
= verbose_dlsym (handle
, "td_ta_map_id2thr");
415 if (td_ta_map_id2thr_p
== NULL
)
418 td_ta_map_lwp2thr_p
= verbose_dlsym (handle
, "td_ta_map_lwp2thr");
419 if (td_ta_map_lwp2thr_p
== NULL
)
422 td_ta_thr_iter_p
= verbose_dlsym (handle
, "td_ta_thr_iter");
423 if (td_ta_thr_iter_p
== NULL
)
426 td_thr_validate_p
= verbose_dlsym (handle
, "td_thr_validate");
427 if (td_thr_validate_p
== NULL
)
430 td_thr_get_info_p
= verbose_dlsym (handle
, "td_thr_get_info");
431 if (td_thr_get_info_p
== NULL
)
434 td_thr_getfpregs_p
= verbose_dlsym (handle
, "td_thr_getfpregs");
435 if (td_thr_getfpregs_p
== NULL
)
438 td_thr_getgregs_p
= verbose_dlsym (handle
, "td_thr_getgregs");
439 if (td_thr_getgregs_p
== NULL
)
442 td_thr_setfpregs_p
= verbose_dlsym (handle
, "td_thr_setfpregs");
443 if (td_thr_setfpregs_p
== NULL
)
446 td_thr_setgregs_p
= verbose_dlsym (handle
, "td_thr_setgregs");
447 if (td_thr_setgregs_p
== NULL
)
450 /* Initialize the library. */
454 warning ("Cannot initialize libthread_db: %s", thread_db_err_str (err
));
458 /* These are not essential. */
459 td_ta_event_addr_p
= dlsym (handle
, "td_ta_event_addr");
460 td_ta_set_event_p
= dlsym (handle
, "td_ta_set_event");
461 td_ta_event_getmsg_p
= dlsym (handle
, "td_ta_event_getmsg");
462 td_thr_event_enable_p
= dlsym (handle
, "td_thr_event_enable");
463 td_thr_tls_get_addr_p
= dlsym (handle
, "td_thr_tls_get_addr");
469 enable_thread_event (td_thragent_t
*thread_agent
, int event
, CORE_ADDR
*bp
)
474 /* Get the breakpoint address for thread EVENT. */
475 err
= td_ta_event_addr_p (thread_agent
, event
, ¬ify
);
479 /* Set up the breakpoint. */
480 (*bp
) = gdbarch_convert_from_func_ptr_addr (current_gdbarch
,
481 (CORE_ADDR
) notify
.u
.bptaddr
,
483 create_thread_event_breakpoint ((*bp
));
489 enable_thread_event_reporting (void)
491 td_thr_events_t events
;
495 /* We cannot use the thread event reporting facility if these
496 functions aren't available. */
497 if (td_ta_event_addr_p
== NULL
|| td_ta_set_event_p
== NULL
498 || td_ta_event_getmsg_p
== NULL
|| td_thr_event_enable_p
== NULL
)
501 /* Set the process wide mask saying which events we're interested in. */
502 td_event_emptyset (&events
);
503 td_event_addset (&events
, TD_CREATE
);
505 /* FIXME: kettenis/2000-04-23: The event reporting facility is
506 broken for TD_DEATH events in glibc 2.1.3, so don't enable it for
508 td_event_addset (&events
, TD_DEATH
);
511 err
= td_ta_set_event_p (thread_agent
, &events
);
514 warning ("Unable to set global thread event mask: %s",
515 thread_db_err_str (err
));
519 /* Delete previous thread event breakpoints, if any. */
520 remove_thread_event_breakpoints ();
521 td_create_bp_addr
= 0;
522 td_death_bp_addr
= 0;
524 /* Set up the thread creation event. */
525 if (!enable_thread_event (thread_agent
, TD_CREATE
, &td_create_bp_addr
))
527 warning ("Unable to get location for thread creation breakpoint: %s",
528 thread_db_err_str (err
));
532 /* Set up the thread death event. */
533 if (!enable_thread_event (thread_agent
, TD_DEATH
, &td_death_bp_addr
))
535 warning ("Unable to get location for thread death breakpoint: %s",
536 thread_db_err_str (err
));
542 disable_thread_event_reporting (void)
544 td_thr_events_t events
;
546 /* Set the process wide mask saying we aren't interested in any
548 td_event_emptyset (&events
);
549 td_ta_set_event_p (thread_agent
, &events
);
551 /* Delete thread event breakpoints, if any. */
552 remove_thread_event_breakpoints ();
553 td_create_bp_addr
= 0;
554 td_death_bp_addr
= 0;
558 check_thread_signals (void)
560 #ifdef GET_THREAD_SIGNALS
566 GET_THREAD_SIGNALS (&mask
);
567 sigemptyset (&thread_stop_set
);
568 sigemptyset (&thread_print_set
);
570 for (i
= 1; i
< NSIG
; i
++)
572 if (sigismember (&mask
, i
))
574 if (signal_stop_update (target_signal_from_host (i
), 0))
575 sigaddset (&thread_stop_set
, i
);
576 if (signal_print_update (target_signal_from_host (i
), 0))
577 sigaddset (&thread_print_set
, i
);
586 disable_thread_signals (void)
588 #ifdef GET_THREAD_SIGNALS
593 for (i
= 1; i
< NSIG
; i
++)
595 if (sigismember (&thread_stop_set
, i
))
596 signal_stop_update (target_signal_from_host (i
), 1);
597 if (sigismember (&thread_print_set
, i
))
598 signal_print_update (target_signal_from_host (i
), 1);
607 thread_db_new_objfile (struct objfile
*objfile
)
611 /* First time through, report that libthread_db was successfuly
612 loaded. Can't print this in in thread_db_load as, at that stage,
613 the interpreter and it's console haven't started. The real
614 problem here is that libthread_db is loaded too early - it should
615 only be loaded when there is a program to debug. */
621 const char *library
= NULL
;
623 if (dladdr ((*td_ta_new_p
), &info
) != 0)
624 library
= info
.dli_fname
;
627 /* Paranoid - don't let a NULL path slip through. */
628 library
= LIBTHREAD_DB_SO
;
629 printf_unfiltered ("Using host libthread_db library \"%s\".\n",
635 /* Don't attempt to use thread_db on targets which can not run
637 if (objfile
== NULL
|| !target_has_execution
)
639 /* All symbols have been discarded. If the thread_db target is
640 active, deactivate it now. */
643 gdb_assert (proc_handle
.pid
== 0);
644 unpush_target (&thread_db_ops
);
654 /* Nothing to do. The thread library was already detected and the
655 target vector was already activated. */
658 /* Initialize the structure that identifies the child process. Note
659 that at this point there is no guarantee that we actually have a
661 proc_handle
.pid
= GET_PID (inferior_ptid
);
663 /* Now attempt to open a connection to the thread library. */
664 err
= td_ta_new_p (&proc_handle
, &thread_agent
);
668 /* No thread library was detected. */
672 printf_unfiltered ("[Thread debugging using libthread_db enabled]\n");
674 /* The thread library was detected. Activate the thread_db target. */
675 push_target (&thread_db_ops
);
678 /* If the thread library was detected in the main symbol file
679 itself, we assume that the program was statically linked
680 against the thread library and well have to keep this
681 module's target vector activated until forever... Well, at
682 least until all symbols have been discarded anyway (see
684 if (objfile
== symfile_objfile
)
686 gdb_assert (proc_handle
.pid
== 0);
690 /* We can only poke around if there actually is a child process.
691 If there is no child process alive, postpone the steps below
692 until one has been created. */
693 if (proc_handle
.pid
!= 0)
695 enable_thread_event_reporting ();
696 thread_db_find_new_threads ();
701 warning ("Cannot initialize thread debugging library: %s",
702 thread_db_err_str (err
));
707 if (target_new_objfile_chain
)
708 target_new_objfile_chain (objfile
);
712 attach_thread (ptid_t ptid
, const td_thrhandle_t
*th_p
,
713 const td_thrinfo_t
*ti_p
, int verbose
)
715 struct thread_info
*tp
;
718 check_thread_signals ();
720 /* Add the thread to GDB's thread list. */
721 tp
= add_thread (ptid
);
722 tp
->private = xmalloc (sizeof (struct private_thread_info
));
723 memset (tp
->private, 0, sizeof (struct private_thread_info
));
726 printf_unfiltered ("[New %s]\n", target_pid_to_str (ptid
));
728 if (ti_p
->ti_state
== TD_THR_UNKNOWN
|| ti_p
->ti_state
== TD_THR_ZOMBIE
)
729 return; /* A zombie thread -- do not attach. */
731 /* Under GNU/Linux, we have to attach to each and every thread. */
733 ATTACH_LWP (BUILD_LWP (ti_p
->ti_lid
, GET_PID (ptid
)), 0);
736 /* Enable thread event reporting for this thread. */
737 err
= td_thr_event_enable_p (th_p
, 1);
739 error ("Cannot enable thread event reporting for %s: %s",
740 target_pid_to_str (ptid
), thread_db_err_str (err
));
744 thread_db_attach (char *args
, int from_tty
)
746 target_beneath
->to_attach (args
, from_tty
);
748 /* Destroy thread info; it's no longer valid. */
751 /* The child process is now the actual multi-threaded
752 program. Snatch its process ID... */
753 proc_handle
.pid
= GET_PID (inferior_ptid
);
755 /* ...and perform the remaining initialization steps. */
756 enable_thread_event_reporting ();
757 thread_db_find_new_threads ();
761 detach_thread (ptid_t ptid
, int verbose
)
764 printf_unfiltered ("[%s exited]\n", target_pid_to_str (ptid
));
768 thread_db_detach (char *args
, int from_tty
)
770 disable_thread_event_reporting ();
772 /* There's no need to save & restore inferior_ptid here, since the
773 inferior is supposed to be survive this function call. */
774 inferior_ptid
= lwp_from_thread (inferior_ptid
);
776 /* Forget about the child's process ID. We shouldn't need it
780 target_beneath
->to_detach (args
, from_tty
);
784 clear_lwpid_callback (struct thread_info
*thread
, void *dummy
)
786 /* If we know that our thread implementation is 1-to-1, we could save
787 a certain amount of information; it's not clear how much, so we
788 are always conservative. */
790 thread
->private->th_valid
= 0;
791 thread
->private->ti_valid
= 0;
797 thread_db_resume (ptid_t ptid
, int step
, enum target_signal signo
)
799 struct cleanup
*old_chain
= save_inferior_ptid ();
801 if (GET_PID (ptid
) == -1)
802 inferior_ptid
= lwp_from_thread (inferior_ptid
);
803 else if (is_thread (ptid
))
804 ptid
= lwp_from_thread (ptid
);
806 /* Clear cached data which may not be valid after the resume. */
807 iterate_over_threads (clear_lwpid_callback
, NULL
);
809 target_beneath
->to_resume (ptid
, step
, signo
);
811 do_cleanups (old_chain
);
814 /* Check if PID is currently stopped at the location of a thread event
815 breakpoint location. If it is, read the event message and act upon
819 check_event (ptid_t ptid
)
827 /* Bail out early if we're not at a thread event breakpoint. */
828 stop_pc
= read_pc_pid (ptid
) - DECR_PC_AFTER_BREAK
;
829 if (stop_pc
!= td_create_bp_addr
&& stop_pc
!= td_death_bp_addr
)
832 /* If we are at a create breakpoint, we do not know what new lwp
833 was created and cannot specifically locate the event message for it.
834 We have to call td_ta_event_getmsg() to get
835 the latest message. Since we have no way of correlating whether
836 the event message we get back corresponds to our breakpoint, we must
837 loop and read all event messages, processing them appropriately.
838 This guarantees we will process the correct message before continuing
841 Currently, death events are not enabled. If they are enabled,
842 the death event can use the td_thr_event_getmsg() interface to
843 get the message specifically for that lwp and avoid looping
850 err
= td_ta_event_getmsg_p (thread_agent
, &msg
);
856 error ("Cannot get thread event message: %s",
857 thread_db_err_str (err
));
860 err
= td_thr_get_info_p (msg
.th_p
, &ti
);
862 error ("Cannot get thread info: %s", thread_db_err_str (err
));
864 ptid
= BUILD_THREAD (ti
.ti_tid
, GET_PID (ptid
));
870 /* We may already know about this thread, for instance when the
871 user has issued the `info threads' command before the SIGTRAP
872 for hitting the thread creation breakpoint was reported. */
873 if (!in_thread_list (ptid
))
874 attach_thread (ptid
, msg
.th_p
, &ti
, 1);
880 if (!in_thread_list (ptid
))
881 error ("Spurious thread death event.");
883 detach_thread (ptid
, 1);
888 error ("Spurious thread event.");
895 thread_db_wait (ptid_t ptid
, struct target_waitstatus
*ourstatus
)
897 extern ptid_t trap_ptid
;
899 if (GET_PID (ptid
) != -1 && is_thread (ptid
))
900 ptid
= lwp_from_thread (ptid
);
902 ptid
= target_beneath
->to_wait (ptid
, ourstatus
);
904 if (proc_handle
.pid
== 0)
905 /* The current child process isn't the actual multi-threaded
906 program yet, so don't try to do any special thread-specific
907 post-processing and bail out early. */
910 if (ourstatus
->kind
== TARGET_WAITKIND_EXITED
)
911 return pid_to_ptid (-1);
913 if (ourstatus
->kind
== TARGET_WAITKIND_STOPPED
914 && ourstatus
->value
.sig
== TARGET_SIGNAL_TRAP
)
915 /* Check for a thread event. */
918 if (!ptid_equal (trap_ptid
, null_ptid
))
919 trap_ptid
= thread_from_lwp (trap_ptid
);
921 return thread_from_lwp (ptid
);
925 thread_db_xfer_memory (CORE_ADDR memaddr
, char *myaddr
, int len
, int write
,
926 struct mem_attrib
*attrib
, struct target_ops
*target
)
928 struct cleanup
*old_chain
= save_inferior_ptid ();
931 if (is_thread (inferior_ptid
))
933 /* FIXME: This seems to be necessary to make sure breakpoints
935 if (!target_thread_alive (inferior_ptid
))
936 inferior_ptid
= pid_to_ptid (GET_PID (inferior_ptid
));
938 inferior_ptid
= lwp_from_thread (inferior_ptid
);
942 target_beneath
->to_xfer_memory (memaddr
, myaddr
, len
, write
, attrib
,
945 do_cleanups (old_chain
);
950 thread_db_fetch_registers (int regno
)
952 struct thread_info
*thread_info
;
954 gdb_prfpregset_t fpregset
;
957 if (!is_thread (inferior_ptid
))
959 /* Pass the request to the target beneath us. */
960 target_beneath
->to_fetch_registers (regno
);
964 thread_info
= find_thread_pid (inferior_ptid
);
965 thread_db_map_id2thr (thread_info
, 1);
967 err
= td_thr_getgregs_p (&thread_info
->private->th
, gregset
);
969 error ("Cannot fetch general-purpose registers for thread %ld: %s",
970 (long) GET_THREAD (inferior_ptid
), thread_db_err_str (err
));
972 err
= td_thr_getfpregs_p (&thread_info
->private->th
, &fpregset
);
974 error ("Cannot get floating-point registers for thread %ld: %s",
975 (long) GET_THREAD (inferior_ptid
), thread_db_err_str (err
));
977 /* Note that we must call supply_gregset after calling the thread_db
978 routines because the thread_db routines call ps_lgetgregs and
979 friends which clobber GDB's register cache. */
980 supply_gregset ((gdb_gregset_t
*) gregset
);
981 supply_fpregset (&fpregset
);
985 thread_db_store_registers (int regno
)
988 gdb_prfpregset_t fpregset
;
990 struct thread_info
*thread_info
;
992 if (!is_thread (inferior_ptid
))
994 /* Pass the request to the target beneath us. */
995 target_beneath
->to_store_registers (regno
);
999 thread_info
= find_thread_pid (inferior_ptid
);
1000 thread_db_map_id2thr (thread_info
, 1);
1004 char raw
[MAX_REGISTER_SIZE
];
1006 deprecated_read_register_gen (regno
, raw
);
1007 thread_db_fetch_registers (-1);
1008 supply_register (regno
, raw
);
1011 fill_gregset ((gdb_gregset_t
*) gregset
, -1);
1012 fill_fpregset (&fpregset
, -1);
1014 err
= td_thr_setgregs_p (&thread_info
->private->th
, gregset
);
1016 error ("Cannot store general-purpose registers for thread %ld: %s",
1017 (long) GET_THREAD (inferior_ptid
), thread_db_err_str (err
));
1018 err
= td_thr_setfpregs_p (&thread_info
->private->th
, &fpregset
);
1020 error ("Cannot store floating-point registers for thread %ld: %s",
1021 (long) GET_THREAD (inferior_ptid
), thread_db_err_str (err
));
1025 thread_db_kill (void)
1027 /* There's no need to save & restore inferior_ptid here, since the
1028 inferior isn't supposed to survive this function call. */
1029 inferior_ptid
= lwp_from_thread (inferior_ptid
);
1030 target_beneath
->to_kill ();
1034 thread_db_create_inferior (char *exec_file
, char *allargs
, char **env
)
1036 if (!keep_thread_db
)
1038 unpush_target (&thread_db_ops
);
1039 using_thread_db
= 0;
1042 target_beneath
->to_create_inferior (exec_file
, allargs
, env
);
1046 thread_db_post_startup_inferior (ptid_t ptid
)
1048 if (proc_handle
.pid
== 0)
1050 /* The child process is now the actual multi-threaded
1051 program. Snatch its process ID... */
1052 proc_handle
.pid
= GET_PID (ptid
);
1054 /* ...and perform the remaining initialization steps. */
1055 enable_thread_event_reporting ();
1056 thread_db_find_new_threads ();
1061 thread_db_mourn_inferior (void)
1063 remove_thread_event_breakpoints ();
1065 /* Forget about the child's process ID. We shouldn't need it
1067 proc_handle
.pid
= 0;
1069 target_beneath
->to_mourn_inferior ();
1071 /* Detach thread_db target ops if not dealing with a statically
1072 linked threaded program. This allows a corefile to be debugged
1073 after finishing debugging of a threaded program. At present,
1074 debugging a statically-linked threaded program is broken, but
1075 the check is added below in the event that it is fixed in the
1077 if (!keep_thread_db
)
1079 unpush_target (&thread_db_ops
);
1080 using_thread_db
= 0;
1085 thread_db_thread_alive (ptid_t ptid
)
1090 if (is_thread (ptid
))
1092 struct thread_info
*thread_info
;
1093 thread_info
= find_thread_pid (ptid
);
1095 thread_db_map_id2thr (thread_info
, 0);
1096 if (!thread_info
->private->th_valid
)
1099 err
= td_thr_validate_p (&thread_info
->private->th
);
1103 if (!thread_info
->private->ti_valid
)
1106 td_thr_get_info_p (&thread_info
->private->th
,
1107 &thread_info
->private->ti
);
1110 thread_info
->private->ti_valid
= 1;
1113 if (thread_info
->private->ti
.ti_state
== TD_THR_UNKNOWN
1114 || thread_info
->private->ti
.ti_state
== TD_THR_ZOMBIE
)
1115 return 0; /* A zombie thread. */
1120 if (target_beneath
->to_thread_alive
)
1121 return target_beneath
->to_thread_alive (ptid
);
1127 find_new_threads_callback (const td_thrhandle_t
*th_p
, void *data
)
1133 err
= td_thr_get_info_p (th_p
, &ti
);
1135 error ("find_new_threads_callback: cannot get thread info: %s",
1136 thread_db_err_str (err
));
1138 if (ti
.ti_state
== TD_THR_UNKNOWN
|| ti
.ti_state
== TD_THR_ZOMBIE
)
1139 return 0; /* A zombie -- ignore. */
1141 ptid
= BUILD_THREAD (ti
.ti_tid
, GET_PID (inferior_ptid
));
1143 if (!in_thread_list (ptid
))
1144 attach_thread (ptid
, th_p
, &ti
, 1);
1150 thread_db_find_new_threads (void)
1154 /* Iterate over all user-space threads to discover new threads. */
1155 err
= td_ta_thr_iter_p (thread_agent
, find_new_threads_callback
, NULL
,
1156 TD_THR_ANY_STATE
, TD_THR_LOWEST_PRIORITY
,
1157 TD_SIGNO_MASK
, TD_THR_ANY_USER_FLAGS
);
1159 error ("Cannot find new threads: %s", thread_db_err_str (err
));
1163 thread_db_pid_to_str (ptid_t ptid
)
1165 if (is_thread (ptid
))
1167 static char buf
[64];
1170 struct thread_info
*thread_info
;
1172 thread_info
= find_thread_pid (ptid
);
1173 thread_db_map_id2thr (thread_info
, 0);
1174 if (!thread_info
->private->th_valid
)
1176 snprintf (buf
, sizeof (buf
), "Thread %ld (Missing)",
1181 ti_p
= thread_db_get_info (thread_info
);
1183 if (ti_p
->ti_state
== TD_THR_ACTIVE
&& ti_p
->ti_lid
!= 0)
1185 snprintf (buf
, sizeof (buf
), "Thread %ld (LWP %d)",
1186 (long) ti_p
->ti_tid
, ti_p
->ti_lid
);
1190 snprintf (buf
, sizeof (buf
), "Thread %ld (%s)",
1191 (long) ti_p
->ti_tid
,
1192 thread_db_state_str (ti_p
->ti_state
));
1198 if (target_beneath
->to_pid_to_str (ptid
))
1199 return target_beneath
->to_pid_to_str (ptid
);
1201 return normal_pid_to_str (ptid
);
1204 /* Get the address of the thread local variable in OBJFILE which is
1205 stored at OFFSET within the thread local storage for thread PTID. */
1208 thread_db_get_thread_local_address (ptid_t ptid
, struct objfile
*objfile
,
1211 if (is_thread (ptid
))
1213 int objfile_is_library
= (objfile
->flags
& OBJF_SHARED
);
1217 struct thread_info
*thread_info
;
1219 /* glibc doesn't provide the needed interface. */
1220 if (!td_thr_tls_get_addr_p
)
1221 error ("Cannot find thread-local variables in this thread library.");
1223 /* Get the address of the link map for this objfile. */
1224 lm
= svr4_fetch_objfile_link_map (objfile
);
1226 /* Whoops, we couldn't find one. Bail out. */
1229 if (objfile_is_library
)
1230 error ("Cannot find shared library `%s' link_map in dynamic"
1231 " linker's module list", objfile
->name
);
1233 error ("Cannot find executable file `%s' link_map in dynamic"
1234 " linker's module list", objfile
->name
);
1237 /* Get info about the thread. */
1238 thread_info
= find_thread_pid (ptid
);
1239 thread_db_map_id2thr (thread_info
, 1);
1241 /* Finally, get the address of the variable. */
1242 err
= td_thr_tls_get_addr_p (&thread_info
->private->th
, (void *) lm
,
1245 #ifdef THREAD_DB_HAS_TD_NOTALLOC
1246 /* The memory hasn't been allocated, yet. */
1247 if (err
== TD_NOTALLOC
)
1249 /* Now, if libthread_db provided the initialization image's
1250 address, we *could* try to build a non-lvalue value from
1251 the initialization image. */
1252 if (objfile_is_library
)
1253 error ("The inferior has not yet allocated storage for"
1254 " thread-local variables in\n"
1255 "the shared library `%s'\n"
1256 "for the thread %ld",
1257 objfile
->name
, (long) GET_THREAD (ptid
));
1259 error ("The inferior has not yet allocated storage for"
1260 " thread-local variables in\n"
1261 "the executable `%s'\n"
1262 "for the thread %ld",
1263 objfile
->name
, (long) GET_THREAD (ptid
));
1267 /* Something else went wrong. */
1270 if (objfile_is_library
)
1271 error ("Cannot find thread-local storage for thread %ld, "
1272 "shared library %s:\n%s",
1273 (long) GET_THREAD (ptid
),
1274 objfile
->name
, thread_db_err_str (err
));
1276 error ("Cannot find thread-local storage for thread %ld, "
1277 "executable file %s:\n%s",
1278 (long) GET_THREAD (ptid
),
1279 objfile
->name
, thread_db_err_str (err
));
1282 /* Cast assuming host == target. Joy. */
1283 return (CORE_ADDR
) address
;
1286 if (target_beneath
->to_get_thread_local_address
)
1287 return target_beneath
->to_get_thread_local_address (ptid
, objfile
,
1290 error ("Cannot find thread-local values on this target.");
1294 init_thread_db_ops (void)
1296 thread_db_ops
.to_shortname
= "multi-thread";
1297 thread_db_ops
.to_longname
= "multi-threaded child process.";
1298 thread_db_ops
.to_doc
= "Threads and pthreads support.";
1299 thread_db_ops
.to_attach
= thread_db_attach
;
1300 thread_db_ops
.to_detach
= thread_db_detach
;
1301 thread_db_ops
.to_resume
= thread_db_resume
;
1302 thread_db_ops
.to_wait
= thread_db_wait
;
1303 thread_db_ops
.to_fetch_registers
= thread_db_fetch_registers
;
1304 thread_db_ops
.to_store_registers
= thread_db_store_registers
;
1305 thread_db_ops
.to_xfer_memory
= thread_db_xfer_memory
;
1306 thread_db_ops
.to_kill
= thread_db_kill
;
1307 thread_db_ops
.to_create_inferior
= thread_db_create_inferior
;
1308 thread_db_ops
.to_post_startup_inferior
= thread_db_post_startup_inferior
;
1309 thread_db_ops
.to_mourn_inferior
= thread_db_mourn_inferior
;
1310 thread_db_ops
.to_thread_alive
= thread_db_thread_alive
;
1311 thread_db_ops
.to_find_new_threads
= thread_db_find_new_threads
;
1312 thread_db_ops
.to_pid_to_str
= thread_db_pid_to_str
;
1313 thread_db_ops
.to_stratum
= thread_stratum
;
1314 thread_db_ops
.to_has_thread_control
= tc_schedlock
;
1315 thread_db_ops
.to_get_thread_local_address
1316 = thread_db_get_thread_local_address
;
1317 thread_db_ops
.to_magic
= OPS_MAGIC
;
1321 _initialize_thread_db (void)
1323 /* Only initialize the module if we can load libthread_db. */
1324 if (thread_db_load ())
1326 init_thread_db_ops ();
1327 add_target (&thread_db_ops
);
1329 /* Add ourselves to objfile event chain. */
1330 target_new_objfile_chain
= target_new_objfile_hook
;
1331 target_new_objfile_hook
= thread_db_new_objfile
;