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 thread_db_load (void)
384 handle
= dlopen (LIBTHREAD_DB_SO
, RTLD_NOW
);
387 fprintf_filtered (gdb_stderr
, "\n\ndlopen failed on '%s' - %s\n",
388 LIBTHREAD_DB_SO
, dlerror ());
389 fprintf_filtered (gdb_stderr
,
390 "GDB will not be able to debug pthreads.\n\n");
394 /* Initialize pointers to the dynamic library functions we will use.
395 Essential functions first. */
397 td_init_p
= dlsym (handle
, "td_init");
398 if (td_init_p
== NULL
)
401 td_ta_new_p
= dlsym (handle
, "td_ta_new");
402 if (td_ta_new_p
== NULL
)
405 td_ta_map_id2thr_p
= dlsym (handle
, "td_ta_map_id2thr");
406 if (td_ta_map_id2thr_p
== NULL
)
409 td_ta_map_lwp2thr_p
= dlsym (handle
, "td_ta_map_lwp2thr");
410 if (td_ta_map_lwp2thr_p
== NULL
)
413 td_ta_thr_iter_p
= dlsym (handle
, "td_ta_thr_iter");
414 if (td_ta_thr_iter_p
== NULL
)
417 td_thr_validate_p
= dlsym (handle
, "td_thr_validate");
418 if (td_thr_validate_p
== NULL
)
421 td_thr_get_info_p
= dlsym (handle
, "td_thr_get_info");
422 if (td_thr_get_info_p
== NULL
)
425 td_thr_getfpregs_p
= dlsym (handle
, "td_thr_getfpregs");
426 if (td_thr_getfpregs_p
== NULL
)
429 td_thr_getgregs_p
= dlsym (handle
, "td_thr_getgregs");
430 if (td_thr_getgregs_p
== NULL
)
433 td_thr_setfpregs_p
= dlsym (handle
, "td_thr_setfpregs");
434 if (td_thr_setfpregs_p
== NULL
)
437 td_thr_setgregs_p
= dlsym (handle
, "td_thr_setgregs");
438 if (td_thr_setgregs_p
== NULL
)
441 /* Initialize the library. */
445 warning ("Cannot initialize libthread_db: %s", thread_db_err_str (err
));
449 /* These are not essential. */
450 td_ta_event_addr_p
= dlsym (handle
, "td_ta_event_addr");
451 td_ta_set_event_p
= dlsym (handle
, "td_ta_set_event");
452 td_ta_event_getmsg_p
= dlsym (handle
, "td_ta_event_getmsg");
453 td_thr_event_enable_p
= dlsym (handle
, "td_thr_event_enable");
454 td_thr_tls_get_addr_p
= dlsym (handle
, "td_thr_tls_get_addr");
460 enable_thread_event_reporting (void)
462 td_thr_events_t events
;
466 /* We cannot use the thread event reporting facility if these
467 functions aren't available. */
468 if (td_ta_event_addr_p
== NULL
|| td_ta_set_event_p
== NULL
469 || td_ta_event_getmsg_p
== NULL
|| td_thr_event_enable_p
== NULL
)
472 /* Set the process wide mask saying which events we're interested in. */
473 td_event_emptyset (&events
);
474 td_event_addset (&events
, TD_CREATE
);
476 /* FIXME: kettenis/2000-04-23: The event reporting facility is
477 broken for TD_DEATH events in glibc 2.1.3, so don't enable it for
479 td_event_addset (&events
, TD_DEATH
);
482 err
= td_ta_set_event_p (thread_agent
, &events
);
485 warning ("Unable to set global thread event mask: %s",
486 thread_db_err_str (err
));
490 /* Delete previous thread event breakpoints, if any. */
491 remove_thread_event_breakpoints ();
493 /* Get address for thread creation breakpoint. */
494 err
= td_ta_event_addr_p (thread_agent
, TD_CREATE
, ¬ify
);
497 warning ("Unable to get location for thread creation breakpoint: %s",
498 thread_db_err_str (err
));
502 /* Set up the breakpoint. */
503 td_create_bp_addr
= (CORE_ADDR
) notify
.u
.bptaddr
;
504 create_thread_event_breakpoint (td_create_bp_addr
);
506 /* Get address for thread death breakpoint. */
507 err
= td_ta_event_addr_p (thread_agent
, TD_DEATH
, ¬ify
);
510 warning ("Unable to get location for thread death breakpoint: %s",
511 thread_db_err_str (err
));
515 /* Set up the breakpoint. */
516 td_death_bp_addr
= (CORE_ADDR
) notify
.u
.bptaddr
;
517 create_thread_event_breakpoint (td_death_bp_addr
);
521 disable_thread_event_reporting (void)
523 td_thr_events_t events
;
525 /* Set the process wide mask saying we aren't interested in any
527 td_event_emptyset (&events
);
528 td_ta_set_event_p (thread_agent
, &events
);
530 /* Delete thread event breakpoints, if any. */
531 remove_thread_event_breakpoints ();
532 td_create_bp_addr
= 0;
533 td_death_bp_addr
= 0;
537 check_thread_signals (void)
539 #ifdef GET_THREAD_SIGNALS
545 GET_THREAD_SIGNALS (&mask
);
546 sigemptyset (&thread_stop_set
);
547 sigemptyset (&thread_print_set
);
549 for (i
= 1; i
< NSIG
; i
++)
551 if (sigismember (&mask
, i
))
553 if (signal_stop_update (target_signal_from_host (i
), 0))
554 sigaddset (&thread_stop_set
, i
);
555 if (signal_print_update (target_signal_from_host (i
), 0))
556 sigaddset (&thread_print_set
, i
);
565 disable_thread_signals (void)
567 #ifdef GET_THREAD_SIGNALS
572 for (i
= 1; i
< NSIG
; i
++)
574 if (sigismember (&thread_stop_set
, i
))
575 signal_stop_update (target_signal_from_host (i
), 1);
576 if (sigismember (&thread_print_set
, i
))
577 signal_print_update (target_signal_from_host (i
), 1);
586 thread_db_new_objfile (struct objfile
*objfile
)
590 /* Don't attempt to use thread_db on targets which can not run
592 if (objfile
== NULL
|| !target_has_execution
)
594 /* All symbols have been discarded. If the thread_db target is
595 active, deactivate it now. */
598 gdb_assert (proc_handle
.pid
== 0);
599 unpush_target (&thread_db_ops
);
609 /* Nothing to do. The thread library was already detected and the
610 target vector was already activated. */
613 /* Initialize the structure that identifies the child process. Note
614 that at this point there is no guarantee that we actually have a
616 proc_handle
.pid
= GET_PID (inferior_ptid
);
618 /* Now attempt to open a connection to the thread library. */
619 err
= td_ta_new_p (&proc_handle
, &thread_agent
);
623 /* No thread library was detected. */
627 /* The thread library was detected. Activate the thread_db target. */
628 push_target (&thread_db_ops
);
631 /* If the thread library was detected in the main symbol file
632 itself, we assume that the program was statically linked
633 against the thread library and well have to keep this
634 module's target vector activated until forever... Well, at
635 least until all symbols have been discarded anyway (see
637 if (objfile
== symfile_objfile
)
639 gdb_assert (proc_handle
.pid
== 0);
643 /* We can only poke around if there actually is a child process.
644 If there is no child process alive, postpone the steps below
645 until one has been created. */
646 if (proc_handle
.pid
!= 0)
648 enable_thread_event_reporting ();
649 thread_db_find_new_threads ();
654 warning ("Cannot initialize thread debugging library: %s",
655 thread_db_err_str (err
));
660 if (target_new_objfile_chain
)
661 target_new_objfile_chain (objfile
);
665 attach_thread (ptid_t ptid
, const td_thrhandle_t
*th_p
,
666 const td_thrinfo_t
*ti_p
, int verbose
)
668 struct thread_info
*tp
;
671 check_thread_signals ();
673 /* Add the thread to GDB's thread list. */
674 tp
= add_thread (ptid
);
675 tp
->private = xmalloc (sizeof (struct private_thread_info
));
676 memset (tp
->private, 0, sizeof (struct private_thread_info
));
679 printf_unfiltered ("[New %s]\n", target_pid_to_str (ptid
));
681 if (ti_p
->ti_state
== TD_THR_UNKNOWN
|| ti_p
->ti_state
== TD_THR_ZOMBIE
)
682 return; /* A zombie thread -- do not attach. */
684 /* Under GNU/Linux, we have to attach to each and every thread. */
686 ATTACH_LWP (BUILD_LWP (ti_p
->ti_lid
, GET_PID (ptid
)), 0);
689 /* Enable thread event reporting for this thread. */
690 err
= td_thr_event_enable_p (th_p
, 1);
692 error ("Cannot enable thread event reporting for %s: %s",
693 target_pid_to_str (ptid
), thread_db_err_str (err
));
697 thread_db_attach (char *args
, int from_tty
)
699 target_beneath
->to_attach (args
, from_tty
);
701 /* Destroy thread info; it's no longer valid. */
704 /* The child process is now the actual multi-threaded
705 program. Snatch its process ID... */
706 proc_handle
.pid
= GET_PID (inferior_ptid
);
708 /* ...and perform the remaining initialization steps. */
709 enable_thread_event_reporting ();
710 thread_db_find_new_threads ();
714 detach_thread (ptid_t ptid
, int verbose
)
717 printf_unfiltered ("[%s exited]\n", target_pid_to_str (ptid
));
721 thread_db_detach (char *args
, int from_tty
)
723 disable_thread_event_reporting ();
725 /* There's no need to save & restore inferior_ptid here, since the
726 inferior is supposed to be survive this function call. */
727 inferior_ptid
= lwp_from_thread (inferior_ptid
);
729 /* Forget about the child's process ID. We shouldn't need it
733 target_beneath
->to_detach (args
, from_tty
);
737 clear_lwpid_callback (struct thread_info
*thread
, void *dummy
)
739 /* If we know that our thread implementation is 1-to-1, we could save
740 a certain amount of information; it's not clear how much, so we
741 are always conservative. */
743 thread
->private->th_valid
= 0;
744 thread
->private->ti_valid
= 0;
750 thread_db_resume (ptid_t ptid
, int step
, enum target_signal signo
)
752 struct cleanup
*old_chain
= save_inferior_ptid ();
754 if (GET_PID (ptid
) == -1)
755 inferior_ptid
= lwp_from_thread (inferior_ptid
);
756 else if (is_thread (ptid
))
757 ptid
= lwp_from_thread (ptid
);
759 /* Clear cached data which may not be valid after the resume. */
760 iterate_over_threads (clear_lwpid_callback
, NULL
);
762 target_beneath
->to_resume (ptid
, step
, signo
);
764 do_cleanups (old_chain
);
767 /* Check if PID is currently stopped at the location of a thread event
768 breakpoint location. If it is, read the event message and act upon
772 check_event (ptid_t ptid
)
780 /* Bail out early if we're not at a thread event breakpoint. */
781 stop_pc
= read_pc_pid (ptid
) - DECR_PC_AFTER_BREAK
;
782 if (stop_pc
!= td_create_bp_addr
&& stop_pc
!= td_death_bp_addr
)
785 /* If we are at a create breakpoint, we do not know what new lwp
786 was created and cannot specifically locate the event message for it.
787 We have to call td_ta_event_getmsg() to get
788 the latest message. Since we have no way of correlating whether
789 the event message we get back corresponds to our breakpoint, we must
790 loop and read all event messages, processing them appropriately.
791 This guarantees we will process the correct message before continuing
794 Currently, death events are not enabled. If they are enabled,
795 the death event can use the td_thr_event_getmsg() interface to
796 get the message specifically for that lwp and avoid looping
803 err
= td_ta_event_getmsg_p (thread_agent
, &msg
);
809 error ("Cannot get thread event message: %s",
810 thread_db_err_str (err
));
813 err
= td_thr_get_info_p (msg
.th_p
, &ti
);
815 error ("Cannot get thread info: %s", thread_db_err_str (err
));
817 ptid
= BUILD_THREAD (ti
.ti_tid
, GET_PID (ptid
));
823 /* We may already know about this thread, for instance when the
824 user has issued the `info threads' command before the SIGTRAP
825 for hitting the thread creation breakpoint was reported. */
826 if (!in_thread_list (ptid
))
827 attach_thread (ptid
, msg
.th_p
, &ti
, 1);
833 if (!in_thread_list (ptid
))
834 error ("Spurious thread death event.");
836 detach_thread (ptid
, 1);
841 error ("Spurious thread event.");
848 thread_db_wait (ptid_t ptid
, struct target_waitstatus
*ourstatus
)
850 extern ptid_t trap_ptid
;
852 if (GET_PID (ptid
) != -1 && is_thread (ptid
))
853 ptid
= lwp_from_thread (ptid
);
855 ptid
= target_beneath
->to_wait (ptid
, ourstatus
);
857 if (proc_handle
.pid
== 0)
858 /* The current child process isn't the actual multi-threaded
859 program yet, so don't try to do any special thread-specific
860 post-processing and bail out early. */
863 if (ourstatus
->kind
== TARGET_WAITKIND_EXITED
)
864 return pid_to_ptid (-1);
866 if (ourstatus
->kind
== TARGET_WAITKIND_STOPPED
867 && ourstatus
->value
.sig
== TARGET_SIGNAL_TRAP
)
868 /* Check for a thread event. */
871 if (!ptid_equal (trap_ptid
, null_ptid
))
872 trap_ptid
= thread_from_lwp (trap_ptid
);
874 return thread_from_lwp (ptid
);
878 thread_db_xfer_memory (CORE_ADDR memaddr
, char *myaddr
, int len
, int write
,
879 struct mem_attrib
*attrib
, struct target_ops
*target
)
881 struct cleanup
*old_chain
= save_inferior_ptid ();
884 if (is_thread (inferior_ptid
))
886 /* FIXME: This seems to be necessary to make sure breakpoints
888 if (!target_thread_alive (inferior_ptid
))
889 inferior_ptid
= pid_to_ptid (GET_PID (inferior_ptid
));
891 inferior_ptid
= lwp_from_thread (inferior_ptid
);
895 target_beneath
->to_xfer_memory (memaddr
, myaddr
, len
, write
, attrib
,
898 do_cleanups (old_chain
);
903 thread_db_fetch_registers (int regno
)
905 struct thread_info
*thread_info
;
907 gdb_prfpregset_t fpregset
;
910 if (!is_thread (inferior_ptid
))
912 /* Pass the request to the target beneath us. */
913 target_beneath
->to_fetch_registers (regno
);
917 thread_info
= find_thread_pid (inferior_ptid
);
918 thread_db_map_id2thr (thread_info
, 1);
920 err
= td_thr_getgregs_p (&thread_info
->private->th
, gregset
);
922 error ("Cannot fetch general-purpose registers for thread %ld: %s",
923 (long) GET_THREAD (inferior_ptid
), thread_db_err_str (err
));
925 err
= td_thr_getfpregs_p (&thread_info
->private->th
, &fpregset
);
927 error ("Cannot get floating-point registers for thread %ld: %s",
928 (long) GET_THREAD (inferior_ptid
), thread_db_err_str (err
));
930 /* Note that we must call supply_gregset after calling the thread_db
931 routines because the thread_db routines call ps_lgetgregs and
932 friends which clobber GDB's register cache. */
933 supply_gregset ((gdb_gregset_t
*) gregset
);
934 supply_fpregset (&fpregset
);
938 thread_db_store_registers (int regno
)
941 gdb_prfpregset_t fpregset
;
943 struct thread_info
*thread_info
;
945 if (!is_thread (inferior_ptid
))
947 /* Pass the request to the target beneath us. */
948 target_beneath
->to_store_registers (regno
);
952 thread_info
= find_thread_pid (inferior_ptid
);
953 thread_db_map_id2thr (thread_info
, 1);
957 char raw
[MAX_REGISTER_SIZE
];
959 deprecated_read_register_gen (regno
, raw
);
960 thread_db_fetch_registers (-1);
961 supply_register (regno
, raw
);
964 fill_gregset ((gdb_gregset_t
*) gregset
, -1);
965 fill_fpregset (&fpregset
, -1);
967 err
= td_thr_setgregs_p (&thread_info
->private->th
, gregset
);
969 error ("Cannot store general-purpose registers for thread %ld: %s",
970 (long) GET_THREAD (inferior_ptid
), thread_db_err_str (err
));
971 err
= td_thr_setfpregs_p (&thread_info
->private->th
, &fpregset
);
973 error ("Cannot store floating-point registers for thread %ld: %s",
974 (long) GET_THREAD (inferior_ptid
), thread_db_err_str (err
));
978 thread_db_kill (void)
980 /* There's no need to save & restore inferior_ptid here, since the
981 inferior isn't supposed to survive this function call. */
982 inferior_ptid
= lwp_from_thread (inferior_ptid
);
983 target_beneath
->to_kill ();
987 thread_db_create_inferior (char *exec_file
, char *allargs
, char **env
)
991 unpush_target (&thread_db_ops
);
995 target_beneath
->to_create_inferior (exec_file
, allargs
, env
);
999 thread_db_post_startup_inferior (ptid_t ptid
)
1001 if (proc_handle
.pid
== 0)
1003 /* The child process is now the actual multi-threaded
1004 program. Snatch its process ID... */
1005 proc_handle
.pid
= GET_PID (ptid
);
1007 /* ...and perform the remaining initialization steps. */
1008 enable_thread_event_reporting ();
1009 thread_db_find_new_threads ();
1014 thread_db_mourn_inferior (void)
1016 remove_thread_event_breakpoints ();
1018 /* Forget about the child's process ID. We shouldn't need it
1020 proc_handle
.pid
= 0;
1022 target_beneath
->to_mourn_inferior ();
1024 /* Detach thread_db target ops if not dealing with a statically
1025 linked threaded program. This allows a corefile to be debugged
1026 after finishing debugging of a threaded program. At present,
1027 debugging a statically-linked threaded program is broken, but
1028 the check is added below in the event that it is fixed in the
1030 if (!keep_thread_db
)
1032 unpush_target (&thread_db_ops
);
1033 using_thread_db
= 0;
1038 thread_db_thread_alive (ptid_t ptid
)
1043 if (is_thread (ptid
))
1045 struct thread_info
*thread_info
;
1046 thread_info
= find_thread_pid (ptid
);
1048 thread_db_map_id2thr (thread_info
, 0);
1049 if (!thread_info
->private->th_valid
)
1052 err
= td_thr_validate_p (&thread_info
->private->th
);
1056 if (!thread_info
->private->ti_valid
)
1059 td_thr_get_info_p (&thread_info
->private->th
,
1060 &thread_info
->private->ti
);
1063 thread_info
->private->ti_valid
= 1;
1066 if (thread_info
->private->ti
.ti_state
== TD_THR_UNKNOWN
1067 || thread_info
->private->ti
.ti_state
== TD_THR_ZOMBIE
)
1068 return 0; /* A zombie thread. */
1073 if (target_beneath
->to_thread_alive
)
1074 return target_beneath
->to_thread_alive (ptid
);
1080 find_new_threads_callback (const td_thrhandle_t
*th_p
, void *data
)
1086 err
= td_thr_get_info_p (th_p
, &ti
);
1088 error ("find_new_threads_callback: cannot get thread info: %s",
1089 thread_db_err_str (err
));
1091 if (ti
.ti_state
== TD_THR_UNKNOWN
|| ti
.ti_state
== TD_THR_ZOMBIE
)
1092 return 0; /* A zombie -- ignore. */
1094 ptid
= BUILD_THREAD (ti
.ti_tid
, GET_PID (inferior_ptid
));
1096 if (!in_thread_list (ptid
))
1097 attach_thread (ptid
, th_p
, &ti
, 1);
1103 thread_db_find_new_threads (void)
1107 /* Iterate over all user-space threads to discover new threads. */
1108 err
= td_ta_thr_iter_p (thread_agent
, find_new_threads_callback
, NULL
,
1109 TD_THR_ANY_STATE
, TD_THR_LOWEST_PRIORITY
,
1110 TD_SIGNO_MASK
, TD_THR_ANY_USER_FLAGS
);
1112 error ("Cannot find new threads: %s", thread_db_err_str (err
));
1116 thread_db_pid_to_str (ptid_t ptid
)
1118 if (is_thread (ptid
))
1120 static char buf
[64];
1123 struct thread_info
*thread_info
;
1125 thread_info
= find_thread_pid (ptid
);
1126 thread_db_map_id2thr (thread_info
, 0);
1127 if (!thread_info
->private->th_valid
)
1129 snprintf (buf
, sizeof (buf
), "Thread %ld (Missing)",
1134 ti_p
= thread_db_get_info (thread_info
);
1136 if (ti_p
->ti_state
== TD_THR_ACTIVE
&& ti_p
->ti_lid
!= 0)
1138 snprintf (buf
, sizeof (buf
), "Thread %ld (LWP %d)",
1139 (long) ti_p
->ti_tid
, ti_p
->ti_lid
);
1143 snprintf (buf
, sizeof (buf
), "Thread %ld (%s)",
1144 (long) ti_p
->ti_tid
,
1145 thread_db_state_str (ti_p
->ti_state
));
1151 if (target_beneath
->to_pid_to_str (ptid
))
1152 return target_beneath
->to_pid_to_str (ptid
);
1154 return normal_pid_to_str (ptid
);
1157 /* Get the address of the thread local variable in OBJFILE which is
1158 stored at OFFSET within the thread local storage for thread PTID. */
1161 thread_db_get_thread_local_address (ptid_t ptid
, struct objfile
*objfile
,
1164 if (is_thread (ptid
))
1166 int objfile_is_library
= (objfile
->flags
& OBJF_SHARED
);
1170 struct thread_info
*thread_info
;
1172 /* glibc doesn't provide the needed interface. */
1173 if (!td_thr_tls_get_addr_p
)
1174 error ("Cannot find thread-local variables in this thread library.");
1176 /* Get the address of the link map for this objfile. */
1177 lm
= svr4_fetch_objfile_link_map (objfile
);
1179 /* Whoops, we couldn't find one. Bail out. */
1182 if (objfile_is_library
)
1183 error ("Cannot find shared library `%s' link_map in dynamic"
1184 " linker's module list", objfile
->name
);
1186 error ("Cannot find executable file `%s' link_map in dynamic"
1187 " linker's module list", objfile
->name
);
1190 /* Get info about the thread. */
1191 thread_info
= find_thread_pid (ptid
);
1192 thread_db_map_id2thr (thread_info
, 1);
1194 /* Finally, get the address of the variable. */
1195 err
= td_thr_tls_get_addr_p (&thread_info
->private->th
, (void *) lm
,
1198 #ifdef THREAD_DB_HAS_TD_NOTALLOC
1199 /* The memory hasn't been allocated, yet. */
1200 if (err
== TD_NOTALLOC
)
1202 /* Now, if libthread_db provided the initialization image's
1203 address, we *could* try to build a non-lvalue value from
1204 the initialization image. */
1205 if (objfile_is_library
)
1206 error ("The inferior has not yet allocated storage for"
1207 " thread-local variables in\n"
1208 "the shared library `%s'\n"
1209 "for the thread %ld",
1210 objfile
->name
, (long) GET_THREAD (ptid
));
1212 error ("The inferior has not yet allocated storage for"
1213 " thread-local variables in\n"
1214 "the executable `%s'\n"
1215 "for the thread %ld",
1216 objfile
->name
, (long) GET_THREAD (ptid
));
1220 /* Something else went wrong. */
1223 if (objfile_is_library
)
1224 error ("Cannot find thread-local storage for thread %ld, "
1225 "shared library %s:\n%s",
1226 (long) GET_THREAD (ptid
),
1227 objfile
->name
, thread_db_err_str (err
));
1229 error ("Cannot find thread-local storage for thread %ld, "
1230 "executable file %s:\n%s",
1231 (long) GET_THREAD (ptid
),
1232 objfile
->name
, thread_db_err_str (err
));
1235 /* Cast assuming host == target. Joy. */
1236 return (CORE_ADDR
) address
;
1239 if (target_beneath
->to_get_thread_local_address
)
1240 return target_beneath
->to_get_thread_local_address (ptid
, objfile
,
1243 error ("Cannot find thread-local values on this target.");
1247 init_thread_db_ops (void)
1249 thread_db_ops
.to_shortname
= "multi-thread";
1250 thread_db_ops
.to_longname
= "multi-threaded child process.";
1251 thread_db_ops
.to_doc
= "Threads and pthreads support.";
1252 thread_db_ops
.to_attach
= thread_db_attach
;
1253 thread_db_ops
.to_detach
= thread_db_detach
;
1254 thread_db_ops
.to_resume
= thread_db_resume
;
1255 thread_db_ops
.to_wait
= thread_db_wait
;
1256 thread_db_ops
.to_fetch_registers
= thread_db_fetch_registers
;
1257 thread_db_ops
.to_store_registers
= thread_db_store_registers
;
1258 thread_db_ops
.to_xfer_memory
= thread_db_xfer_memory
;
1259 thread_db_ops
.to_kill
= thread_db_kill
;
1260 thread_db_ops
.to_create_inferior
= thread_db_create_inferior
;
1261 thread_db_ops
.to_post_startup_inferior
= thread_db_post_startup_inferior
;
1262 thread_db_ops
.to_mourn_inferior
= thread_db_mourn_inferior
;
1263 thread_db_ops
.to_thread_alive
= thread_db_thread_alive
;
1264 thread_db_ops
.to_find_new_threads
= thread_db_find_new_threads
;
1265 thread_db_ops
.to_pid_to_str
= thread_db_pid_to_str
;
1266 thread_db_ops
.to_stratum
= thread_stratum
;
1267 thread_db_ops
.to_has_thread_control
= tc_schedlock
;
1268 thread_db_ops
.to_get_thread_local_address
1269 = thread_db_get_thread_local_address
;
1270 thread_db_ops
.to_magic
= OPS_MAGIC
;
1274 _initialize_thread_db (void)
1276 /* Only initialize the module if we can load libthread_db. */
1277 if (thread_db_load ())
1279 init_thread_db_ops ();
1280 add_target (&thread_db_ops
);
1282 /* Add ourselves to objfile event chain. */
1283 target_new_objfile_chain
= target_new_objfile_hook
;
1284 target_new_objfile_hook
= thread_db_new_objfile
;