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 err
= enable_thread_event (thread_agent
, TD_CREATE
, &td_create_bp_addr
);
528 warning ("Unable to get location for thread creation breakpoint: %s",
529 thread_db_err_str (err
));
533 /* Set up the thread death event. */
534 err
= enable_thread_event (thread_agent
, TD_DEATH
, &td_death_bp_addr
);
537 warning ("Unable to get location for thread death breakpoint: %s",
538 thread_db_err_str (err
));
544 disable_thread_event_reporting (void)
546 td_thr_events_t events
;
548 /* Set the process wide mask saying we aren't interested in any
550 td_event_emptyset (&events
);
551 td_ta_set_event_p (thread_agent
, &events
);
553 /* Delete thread event breakpoints, if any. */
554 remove_thread_event_breakpoints ();
555 td_create_bp_addr
= 0;
556 td_death_bp_addr
= 0;
560 check_thread_signals (void)
562 #ifdef GET_THREAD_SIGNALS
568 GET_THREAD_SIGNALS (&mask
);
569 sigemptyset (&thread_stop_set
);
570 sigemptyset (&thread_print_set
);
572 for (i
= 1; i
< NSIG
; i
++)
574 if (sigismember (&mask
, i
))
576 if (signal_stop_update (target_signal_from_host (i
), 0))
577 sigaddset (&thread_stop_set
, i
);
578 if (signal_print_update (target_signal_from_host (i
), 0))
579 sigaddset (&thread_print_set
, i
);
588 disable_thread_signals (void)
590 #ifdef GET_THREAD_SIGNALS
595 for (i
= 1; i
< NSIG
; i
++)
597 if (sigismember (&thread_stop_set
, i
))
598 signal_stop_update (target_signal_from_host (i
), 1);
599 if (sigismember (&thread_print_set
, i
))
600 signal_print_update (target_signal_from_host (i
), 1);
609 thread_db_new_objfile (struct objfile
*objfile
)
613 /* First time through, report that libthread_db was successfuly
614 loaded. Can't print this in in thread_db_load as, at that stage,
615 the interpreter and it's console haven't started. The real
616 problem here is that libthread_db is loaded too early - it should
617 only be loaded when there is a program to debug. */
623 const char *library
= NULL
;
625 if (dladdr ((*td_ta_new_p
), &info
) != 0)
626 library
= info
.dli_fname
;
629 /* Paranoid - don't let a NULL path slip through. */
630 library
= LIBTHREAD_DB_SO
;
631 printf_unfiltered ("Using host libthread_db library \"%s\".\n",
637 /* Don't attempt to use thread_db on targets which can not run
639 if (objfile
== NULL
|| !target_has_execution
)
641 /* All symbols have been discarded. If the thread_db target is
642 active, deactivate it now. */
645 gdb_assert (proc_handle
.pid
== 0);
646 unpush_target (&thread_db_ops
);
656 /* Nothing to do. The thread library was already detected and the
657 target vector was already activated. */
660 /* Initialize the structure that identifies the child process. Note
661 that at this point there is no guarantee that we actually have a
663 proc_handle
.pid
= GET_PID (inferior_ptid
);
665 /* Now attempt to open a connection to the thread library. */
666 err
= td_ta_new_p (&proc_handle
, &thread_agent
);
670 /* No thread library was detected. */
674 printf_unfiltered ("[Thread debugging using libthread_db enabled]\n");
676 /* The thread library was detected. Activate the thread_db target. */
677 push_target (&thread_db_ops
);
680 /* If the thread library was detected in the main symbol file
681 itself, we assume that the program was statically linked
682 against the thread library and well have to keep this
683 module's target vector activated until forever... Well, at
684 least until all symbols have been discarded anyway (see
686 if (objfile
== symfile_objfile
)
688 gdb_assert (proc_handle
.pid
== 0);
692 /* We can only poke around if there actually is a child process.
693 If there is no child process alive, postpone the steps below
694 until one has been created. */
695 if (proc_handle
.pid
!= 0)
697 enable_thread_event_reporting ();
698 thread_db_find_new_threads ();
703 warning ("Cannot initialize thread debugging library: %s",
704 thread_db_err_str (err
));
709 if (target_new_objfile_chain
)
710 target_new_objfile_chain (objfile
);
714 attach_thread (ptid_t ptid
, const td_thrhandle_t
*th_p
,
715 const td_thrinfo_t
*ti_p
, int verbose
)
717 struct thread_info
*tp
;
720 check_thread_signals ();
722 /* Add the thread to GDB's thread list. */
723 tp
= add_thread (ptid
);
724 tp
->private = xmalloc (sizeof (struct private_thread_info
));
725 memset (tp
->private, 0, sizeof (struct private_thread_info
));
728 printf_unfiltered ("[New %s]\n", target_pid_to_str (ptid
));
730 if (ti_p
->ti_state
== TD_THR_UNKNOWN
|| ti_p
->ti_state
== TD_THR_ZOMBIE
)
731 return; /* A zombie thread -- do not attach. */
733 /* Under GNU/Linux, we have to attach to each and every thread. */
735 ATTACH_LWP (BUILD_LWP (ti_p
->ti_lid
, GET_PID (ptid
)), 0);
738 /* Enable thread event reporting for this thread. */
739 err
= td_thr_event_enable_p (th_p
, 1);
741 error ("Cannot enable thread event reporting for %s: %s",
742 target_pid_to_str (ptid
), thread_db_err_str (err
));
746 thread_db_attach (char *args
, int from_tty
)
748 target_beneath
->to_attach (args
, from_tty
);
750 /* Destroy thread info; it's no longer valid. */
753 /* The child process is now the actual multi-threaded
754 program. Snatch its process ID... */
755 proc_handle
.pid
= GET_PID (inferior_ptid
);
757 /* ...and perform the remaining initialization steps. */
758 enable_thread_event_reporting ();
759 thread_db_find_new_threads ();
763 detach_thread (ptid_t ptid
, int verbose
)
766 printf_unfiltered ("[%s exited]\n", target_pid_to_str (ptid
));
770 thread_db_detach (char *args
, int from_tty
)
772 disable_thread_event_reporting ();
774 /* There's no need to save & restore inferior_ptid here, since the
775 inferior is supposed to be survive this function call. */
776 inferior_ptid
= lwp_from_thread (inferior_ptid
);
778 /* Forget about the child's process ID. We shouldn't need it
782 target_beneath
->to_detach (args
, from_tty
);
786 clear_lwpid_callback (struct thread_info
*thread
, void *dummy
)
788 /* If we know that our thread implementation is 1-to-1, we could save
789 a certain amount of information; it's not clear how much, so we
790 are always conservative. */
792 thread
->private->th_valid
= 0;
793 thread
->private->ti_valid
= 0;
799 thread_db_resume (ptid_t ptid
, int step
, enum target_signal signo
)
801 struct cleanup
*old_chain
= save_inferior_ptid ();
803 if (GET_PID (ptid
) == -1)
804 inferior_ptid
= lwp_from_thread (inferior_ptid
);
805 else if (is_thread (ptid
))
806 ptid
= lwp_from_thread (ptid
);
808 /* Clear cached data which may not be valid after the resume. */
809 iterate_over_threads (clear_lwpid_callback
, NULL
);
811 target_beneath
->to_resume (ptid
, step
, signo
);
813 do_cleanups (old_chain
);
816 /* Check if PID is currently stopped at the location of a thread event
817 breakpoint location. If it is, read the event message and act upon
821 check_event (ptid_t ptid
)
829 /* Bail out early if we're not at a thread event breakpoint. */
830 stop_pc
= read_pc_pid (ptid
) - DECR_PC_AFTER_BREAK
;
831 if (stop_pc
!= td_create_bp_addr
&& stop_pc
!= td_death_bp_addr
)
834 /* If we are at a create breakpoint, we do not know what new lwp
835 was created and cannot specifically locate the event message for it.
836 We have to call td_ta_event_getmsg() to get
837 the latest message. Since we have no way of correlating whether
838 the event message we get back corresponds to our breakpoint, we must
839 loop and read all event messages, processing them appropriately.
840 This guarantees we will process the correct message before continuing
843 Currently, death events are not enabled. If they are enabled,
844 the death event can use the td_thr_event_getmsg() interface to
845 get the message specifically for that lwp and avoid looping
852 err
= td_ta_event_getmsg_p (thread_agent
, &msg
);
858 error ("Cannot get thread event message: %s",
859 thread_db_err_str (err
));
862 err
= td_thr_get_info_p (msg
.th_p
, &ti
);
864 error ("Cannot get thread info: %s", thread_db_err_str (err
));
866 ptid
= BUILD_THREAD (ti
.ti_tid
, GET_PID (ptid
));
872 /* We may already know about this thread, for instance when the
873 user has issued the `info threads' command before the SIGTRAP
874 for hitting the thread creation breakpoint was reported. */
875 if (!in_thread_list (ptid
))
876 attach_thread (ptid
, msg
.th_p
, &ti
, 1);
882 if (!in_thread_list (ptid
))
883 error ("Spurious thread death event.");
885 detach_thread (ptid
, 1);
890 error ("Spurious thread event.");
897 thread_db_wait (ptid_t ptid
, struct target_waitstatus
*ourstatus
)
899 extern ptid_t trap_ptid
;
901 if (GET_PID (ptid
) != -1 && is_thread (ptid
))
902 ptid
= lwp_from_thread (ptid
);
904 ptid
= target_beneath
->to_wait (ptid
, ourstatus
);
906 if (proc_handle
.pid
== 0)
907 /* The current child process isn't the actual multi-threaded
908 program yet, so don't try to do any special thread-specific
909 post-processing and bail out early. */
912 if (ourstatus
->kind
== TARGET_WAITKIND_EXITED
)
913 return pid_to_ptid (-1);
915 if (ourstatus
->kind
== TARGET_WAITKIND_STOPPED
916 && ourstatus
->value
.sig
== TARGET_SIGNAL_TRAP
)
917 /* Check for a thread event. */
920 if (!ptid_equal (trap_ptid
, null_ptid
))
921 trap_ptid
= thread_from_lwp (trap_ptid
);
923 return thread_from_lwp (ptid
);
927 thread_db_xfer_memory (CORE_ADDR memaddr
, char *myaddr
, int len
, int write
,
928 struct mem_attrib
*attrib
, struct target_ops
*target
)
930 struct cleanup
*old_chain
= save_inferior_ptid ();
933 if (is_thread (inferior_ptid
))
935 /* FIXME: This seems to be necessary to make sure breakpoints
937 if (!target_thread_alive (inferior_ptid
))
938 inferior_ptid
= pid_to_ptid (GET_PID (inferior_ptid
));
940 inferior_ptid
= lwp_from_thread (inferior_ptid
);
944 target_beneath
->to_xfer_memory (memaddr
, myaddr
, len
, write
, attrib
,
947 do_cleanups (old_chain
);
952 thread_db_fetch_registers (int regno
)
954 struct thread_info
*thread_info
;
956 gdb_prfpregset_t fpregset
;
959 if (!is_thread (inferior_ptid
))
961 /* Pass the request to the target beneath us. */
962 target_beneath
->to_fetch_registers (regno
);
966 thread_info
= find_thread_pid (inferior_ptid
);
967 thread_db_map_id2thr (thread_info
, 1);
969 err
= td_thr_getgregs_p (&thread_info
->private->th
, gregset
);
971 error ("Cannot fetch general-purpose registers for thread %ld: %s",
972 (long) GET_THREAD (inferior_ptid
), thread_db_err_str (err
));
974 err
= td_thr_getfpregs_p (&thread_info
->private->th
, &fpregset
);
976 error ("Cannot get floating-point registers for thread %ld: %s",
977 (long) GET_THREAD (inferior_ptid
), thread_db_err_str (err
));
979 /* Note that we must call supply_gregset after calling the thread_db
980 routines because the thread_db routines call ps_lgetgregs and
981 friends which clobber GDB's register cache. */
982 supply_gregset ((gdb_gregset_t
*) gregset
);
983 supply_fpregset (&fpregset
);
987 thread_db_store_registers (int regno
)
990 gdb_prfpregset_t fpregset
;
992 struct thread_info
*thread_info
;
994 if (!is_thread (inferior_ptid
))
996 /* Pass the request to the target beneath us. */
997 target_beneath
->to_store_registers (regno
);
1001 thread_info
= find_thread_pid (inferior_ptid
);
1002 thread_db_map_id2thr (thread_info
, 1);
1006 char raw
[MAX_REGISTER_SIZE
];
1008 deprecated_read_register_gen (regno
, raw
);
1009 thread_db_fetch_registers (-1);
1010 supply_register (regno
, raw
);
1013 fill_gregset ((gdb_gregset_t
*) gregset
, -1);
1014 fill_fpregset (&fpregset
, -1);
1016 err
= td_thr_setgregs_p (&thread_info
->private->th
, gregset
);
1018 error ("Cannot store general-purpose registers for thread %ld: %s",
1019 (long) GET_THREAD (inferior_ptid
), thread_db_err_str (err
));
1020 err
= td_thr_setfpregs_p (&thread_info
->private->th
, &fpregset
);
1022 error ("Cannot store floating-point registers for thread %ld: %s",
1023 (long) GET_THREAD (inferior_ptid
), thread_db_err_str (err
));
1027 thread_db_kill (void)
1029 /* There's no need to save & restore inferior_ptid here, since the
1030 inferior isn't supposed to survive this function call. */
1031 inferior_ptid
= lwp_from_thread (inferior_ptid
);
1032 target_beneath
->to_kill ();
1036 thread_db_create_inferior (char *exec_file
, char *allargs
, char **env
)
1038 if (!keep_thread_db
)
1040 unpush_target (&thread_db_ops
);
1041 using_thread_db
= 0;
1044 target_beneath
->to_create_inferior (exec_file
, allargs
, env
);
1048 thread_db_post_startup_inferior (ptid_t ptid
)
1050 if (proc_handle
.pid
== 0)
1052 /* The child process is now the actual multi-threaded
1053 program. Snatch its process ID... */
1054 proc_handle
.pid
= GET_PID (ptid
);
1056 /* ...and perform the remaining initialization steps. */
1057 enable_thread_event_reporting ();
1058 thread_db_find_new_threads ();
1063 thread_db_mourn_inferior (void)
1065 remove_thread_event_breakpoints ();
1067 /* Forget about the child's process ID. We shouldn't need it
1069 proc_handle
.pid
= 0;
1071 target_beneath
->to_mourn_inferior ();
1073 /* Detach thread_db target ops if not dealing with a statically
1074 linked threaded program. This allows a corefile to be debugged
1075 after finishing debugging of a threaded program. At present,
1076 debugging a statically-linked threaded program is broken, but
1077 the check is added below in the event that it is fixed in the
1079 if (!keep_thread_db
)
1081 unpush_target (&thread_db_ops
);
1082 using_thread_db
= 0;
1087 thread_db_thread_alive (ptid_t ptid
)
1092 if (is_thread (ptid
))
1094 struct thread_info
*thread_info
;
1095 thread_info
= find_thread_pid (ptid
);
1097 thread_db_map_id2thr (thread_info
, 0);
1098 if (!thread_info
->private->th_valid
)
1101 err
= td_thr_validate_p (&thread_info
->private->th
);
1105 if (!thread_info
->private->ti_valid
)
1108 td_thr_get_info_p (&thread_info
->private->th
,
1109 &thread_info
->private->ti
);
1112 thread_info
->private->ti_valid
= 1;
1115 if (thread_info
->private->ti
.ti_state
== TD_THR_UNKNOWN
1116 || thread_info
->private->ti
.ti_state
== TD_THR_ZOMBIE
)
1117 return 0; /* A zombie thread. */
1122 if (target_beneath
->to_thread_alive
)
1123 return target_beneath
->to_thread_alive (ptid
);
1129 find_new_threads_callback (const td_thrhandle_t
*th_p
, void *data
)
1135 err
= td_thr_get_info_p (th_p
, &ti
);
1137 error ("find_new_threads_callback: cannot get thread info: %s",
1138 thread_db_err_str (err
));
1140 if (ti
.ti_state
== TD_THR_UNKNOWN
|| ti
.ti_state
== TD_THR_ZOMBIE
)
1141 return 0; /* A zombie -- ignore. */
1143 ptid
= BUILD_THREAD (ti
.ti_tid
, GET_PID (inferior_ptid
));
1145 if (!in_thread_list (ptid
))
1146 attach_thread (ptid
, th_p
, &ti
, 1);
1152 thread_db_find_new_threads (void)
1156 /* Iterate over all user-space threads to discover new threads. */
1157 err
= td_ta_thr_iter_p (thread_agent
, find_new_threads_callback
, NULL
,
1158 TD_THR_ANY_STATE
, TD_THR_LOWEST_PRIORITY
,
1159 TD_SIGNO_MASK
, TD_THR_ANY_USER_FLAGS
);
1161 error ("Cannot find new threads: %s", thread_db_err_str (err
));
1165 thread_db_pid_to_str (ptid_t ptid
)
1167 if (is_thread (ptid
))
1169 static char buf
[64];
1172 struct thread_info
*thread_info
;
1174 thread_info
= find_thread_pid (ptid
);
1175 thread_db_map_id2thr (thread_info
, 0);
1176 if (!thread_info
->private->th_valid
)
1178 snprintf (buf
, sizeof (buf
), "Thread %ld (Missing)",
1183 ti_p
= thread_db_get_info (thread_info
);
1185 if (ti_p
->ti_state
== TD_THR_ACTIVE
&& ti_p
->ti_lid
!= 0)
1187 snprintf (buf
, sizeof (buf
), "Thread %ld (LWP %d)",
1188 (long) ti_p
->ti_tid
, ti_p
->ti_lid
);
1192 snprintf (buf
, sizeof (buf
), "Thread %ld (%s)",
1193 (long) ti_p
->ti_tid
,
1194 thread_db_state_str (ti_p
->ti_state
));
1200 if (target_beneath
->to_pid_to_str (ptid
))
1201 return target_beneath
->to_pid_to_str (ptid
);
1203 return normal_pid_to_str (ptid
);
1206 /* Get the address of the thread local variable in OBJFILE which is
1207 stored at OFFSET within the thread local storage for thread PTID. */
1210 thread_db_get_thread_local_address (ptid_t ptid
, struct objfile
*objfile
,
1213 if (is_thread (ptid
))
1215 int objfile_is_library
= (objfile
->flags
& OBJF_SHARED
);
1219 struct thread_info
*thread_info
;
1221 /* glibc doesn't provide the needed interface. */
1222 if (!td_thr_tls_get_addr_p
)
1223 error ("Cannot find thread-local variables in this thread library.");
1225 /* Get the address of the link map for this objfile. */
1226 lm
= svr4_fetch_objfile_link_map (objfile
);
1228 /* Whoops, we couldn't find one. Bail out. */
1231 if (objfile_is_library
)
1232 error ("Cannot find shared library `%s' link_map in dynamic"
1233 " linker's module list", objfile
->name
);
1235 error ("Cannot find executable file `%s' link_map in dynamic"
1236 " linker's module list", objfile
->name
);
1239 /* Get info about the thread. */
1240 thread_info
= find_thread_pid (ptid
);
1241 thread_db_map_id2thr (thread_info
, 1);
1243 /* Finally, get the address of the variable. */
1244 err
= td_thr_tls_get_addr_p (&thread_info
->private->th
, (void *) lm
,
1247 #ifdef THREAD_DB_HAS_TD_NOTALLOC
1248 /* The memory hasn't been allocated, yet. */
1249 if (err
== TD_NOTALLOC
)
1251 /* Now, if libthread_db provided the initialization image's
1252 address, we *could* try to build a non-lvalue value from
1253 the initialization image. */
1254 if (objfile_is_library
)
1255 error ("The inferior has not yet allocated storage for"
1256 " thread-local variables in\n"
1257 "the shared library `%s'\n"
1258 "for the thread %ld",
1259 objfile
->name
, (long) GET_THREAD (ptid
));
1261 error ("The inferior has not yet allocated storage for"
1262 " thread-local variables in\n"
1263 "the executable `%s'\n"
1264 "for the thread %ld",
1265 objfile
->name
, (long) GET_THREAD (ptid
));
1269 /* Something else went wrong. */
1272 if (objfile_is_library
)
1273 error ("Cannot find thread-local storage for thread %ld, "
1274 "shared library %s:\n%s",
1275 (long) GET_THREAD (ptid
),
1276 objfile
->name
, thread_db_err_str (err
));
1278 error ("Cannot find thread-local storage for thread %ld, "
1279 "executable file %s:\n%s",
1280 (long) GET_THREAD (ptid
),
1281 objfile
->name
, thread_db_err_str (err
));
1284 /* Cast assuming host == target. Joy. */
1285 return (CORE_ADDR
) address
;
1288 if (target_beneath
->to_get_thread_local_address
)
1289 return target_beneath
->to_get_thread_local_address (ptid
, objfile
,
1292 error ("Cannot find thread-local values on this target.");
1296 init_thread_db_ops (void)
1298 thread_db_ops
.to_shortname
= "multi-thread";
1299 thread_db_ops
.to_longname
= "multi-threaded child process.";
1300 thread_db_ops
.to_doc
= "Threads and pthreads support.";
1301 thread_db_ops
.to_attach
= thread_db_attach
;
1302 thread_db_ops
.to_detach
= thread_db_detach
;
1303 thread_db_ops
.to_resume
= thread_db_resume
;
1304 thread_db_ops
.to_wait
= thread_db_wait
;
1305 thread_db_ops
.to_fetch_registers
= thread_db_fetch_registers
;
1306 thread_db_ops
.to_store_registers
= thread_db_store_registers
;
1307 thread_db_ops
.to_xfer_memory
= thread_db_xfer_memory
;
1308 thread_db_ops
.to_kill
= thread_db_kill
;
1309 thread_db_ops
.to_create_inferior
= thread_db_create_inferior
;
1310 thread_db_ops
.to_post_startup_inferior
= thread_db_post_startup_inferior
;
1311 thread_db_ops
.to_mourn_inferior
= thread_db_mourn_inferior
;
1312 thread_db_ops
.to_thread_alive
= thread_db_thread_alive
;
1313 thread_db_ops
.to_find_new_threads
= thread_db_find_new_threads
;
1314 thread_db_ops
.to_pid_to_str
= thread_db_pid_to_str
;
1315 thread_db_ops
.to_stratum
= thread_stratum
;
1316 thread_db_ops
.to_has_thread_control
= tc_schedlock
;
1317 thread_db_ops
.to_get_thread_local_address
1318 = thread_db_get_thread_local_address
;
1319 thread_db_ops
.to_magic
= OPS_MAGIC
;
1323 _initialize_thread_db (void)
1325 /* Only initialize the module if we can load libthread_db. */
1326 if (thread_db_load ())
1328 init_thread_db_ops ();
1329 add_target (&thread_db_ops
);
1331 /* Add ourselves to objfile event chain. */
1332 target_new_objfile_chain
= target_new_objfile_hook
;
1333 target_new_objfile_hook
= thread_db_new_objfile
;