1 /* libthread_db assisted debugging support, generic parts.
2 Copyright 1999, 2000, 2001 Free Software Foundation, Inc.
4 This file is part of GDB.
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 59 Temple Place - Suite 330,
19 Boston, MA 02111-1307, USA. */
23 #include "gdb_assert.h"
25 #include "gdb_proc_service.h"
26 #include "gdb_thread_db.h"
29 #include "gdbthread.h"
36 #ifndef LIBTHREAD_DB_SO
37 #define LIBTHREAD_DB_SO "libthread_db.so.1"
40 /* If we're running on Linux, we must explicitly attach to any new threads. */
42 /* FIXME: There is certainly some room for improvements:
44 - Bypass libthread_db when fetching or storing registers for
45 threads bound to a LWP. */
47 /* This module's target vector. */
48 static struct target_ops thread_db_ops
;
50 /* The target vector that we call for things this module can't handle. */
51 static struct target_ops
*target_beneath
;
53 /* Pointer to the next function on the objfile event chain. */
54 static void (*target_new_objfile_chain
) (struct objfile
*objfile
);
56 /* Non-zero if we're using this module's target vector. */
57 static int using_thread_db
;
59 /* Non-zero if we musn't deactivate this module's target vector. */
60 static int keep_thread_db
;
62 /* Non-zero if we have determined the signals used by the threads
64 static int thread_signals
;
65 static sigset_t thread_stop_set
;
66 static sigset_t thread_print_set
;
68 /* Structure that identifies the child process for the
69 <proc_service.h> interface. */
70 static struct ps_prochandle proc_handle
;
72 /* Connection to the libthread_db library. */
73 static td_thragent_t
*thread_agent
;
75 /* Pointers to the libthread_db functions. */
77 static td_err_e (*td_init_p
) (void);
79 static td_err_e (*td_ta_new_p
) (struct ps_prochandle
*ps
, td_thragent_t
**ta
);
80 static td_err_e (*td_ta_map_id2thr_p
) (const td_thragent_t
*ta
, thread_t pt
,
81 td_thrhandle_t
*__th
);
82 static td_err_e (*td_ta_map_lwp2thr_p
) (const td_thragent_t
*ta
, lwpid_t lwpid
,
84 static td_err_e (*td_ta_thr_iter_p
) (const td_thragent_t
*ta
,
85 td_thr_iter_f
*callback
,
86 void *cbdata_p
, td_thr_state_e state
,
87 int ti_pri
, sigset_t
*ti_sigmask_p
,
88 unsigned int ti_user_flags
);
89 static td_err_e (*td_ta_event_addr_p
) (const td_thragent_t
*ta
,
90 td_event_e event
, td_notify_t
*ptr
);
91 static td_err_e (*td_ta_set_event_p
) (const td_thragent_t
*ta
,
92 td_thr_events_t
*event
);
93 static td_err_e (*td_ta_event_getmsg_p
) (const td_thragent_t
*ta
,
96 static td_err_e (*td_thr_validate_p
) (const td_thrhandle_t
*th
);
97 static td_err_e (*td_thr_get_info_p
) (const td_thrhandle_t
*th
,
99 static td_err_e (*td_thr_getfpregs_p
) (const td_thrhandle_t
*th
,
100 gdb_prfpregset_t
*regset
);
101 static td_err_e (*td_thr_getgregs_p
) (const td_thrhandle_t
*th
,
103 static td_err_e (*td_thr_setfpregs_p
) (const td_thrhandle_t
*th
,
104 const gdb_prfpregset_t
*fpregs
);
105 static td_err_e (*td_thr_setgregs_p
) (const td_thrhandle_t
*th
,
107 static td_err_e (*td_thr_event_enable_p
) (const td_thrhandle_t
*th
, int event
);
109 /* Location of the thread creation event breakpoint. The code at this
110 location in the child process will be called by the pthread library
111 whenever a new thread is created. By setting a special breakpoint
112 at this location, GDB can detect when a new thread is created. We
113 obtain this location via the td_ta_event_addr call. */
114 static CORE_ADDR td_create_bp_addr
;
116 /* Location of the thread death event breakpoint. */
117 static CORE_ADDR td_death_bp_addr
;
119 /* Prototypes for local functions. */
120 static void thread_db_find_new_threads (void);
123 /* Building process ids. */
126 #define TIDGET(PID) (((PID) & 0x7fffffff) >> 16)
127 #define PIDGET0(PID) (((PID) & 0xffff))
128 #define PIDGET(PID) ((PIDGET0 (PID) == 0xffff) ? -1 : PIDGET0 (PID))
129 #define MERGEPID(PID, TID) (((PID) & 0xffff) | ((TID) << 16))
132 #define THREAD_FLAG 0x80000000
134 #define is_lwp(pid) (((pid) & THREAD_FLAG) == 0 && TIDGET (pid))
135 #define is_thread(pid) ((pid) & THREAD_FLAG)
137 #define GET_PID(pid) PIDGET (pid)
138 #define GET_LWP(pid) TIDGET (pid)
139 #define GET_THREAD(pid) TIDGET (pid)
141 #define BUILD_LWP(tid, pid) MERGEPID (pid, tid)
142 #define BUILD_THREAD(tid, pid) (MERGEPID (pid, tid) | THREAD_FLAG)
145 struct private_thread_info
147 /* Cached LWP id. Must come first, see lin-lwp.c. */
152 /* Helper functions. */
155 restore_inferior_ptid (void *arg
)
157 ptid_t
*saved_ptid_ptr
= arg
;
158 inferior_ptid
= *saved_ptid_ptr
;
162 static struct cleanup
*
163 save_inferior_ptid (void)
165 ptid_t
*saved_ptid_ptr
;
167 saved_ptid_ptr
= xmalloc (sizeof (ptid_t
));
168 *saved_ptid_ptr
= inferior_ptid
;
169 return make_cleanup (restore_inferior_ptid
, saved_ptid_ptr
);
174 thread_db_err_str (td_err_e err
)
181 return "generic 'call succeeded'";
183 return "generic error";
185 return "no thread to satisfy query";
187 return "no sync handle to satisfy query";
189 return "no LWP to satisfy query";
191 return "invalid process handle";
193 return "invalid thread handle";
195 return "invalid synchronization handle";
197 return "invalid thread agent";
199 return "invalid key";
201 return "no event message for getmsg";
203 return "FPU register set not available";
205 return "application not linked with libthread";
207 return "requested event is not supported";
209 return "capability not available";
211 return "debugger service failed";
213 return "operation not applicable to";
215 return "no thread-specific data for this thread";
217 return "malloc failed";
219 return "only part of register set was written/read";
221 return "X register set not available for this thread";
223 snprintf (buf
, sizeof (buf
), "unknown thread_db error '%d'", err
);
229 thread_db_state_str (td_thr_state_e state
)
236 return "stopped by debugger";
245 case TD_THR_STOPPED_ASLEEP
:
246 return "stopped by debugger AND blocked";
248 snprintf (buf
, sizeof (buf
), "unknown thread_db state %d", state
);
254 /* Convert between user-level thread ids and LWP ids. */
257 thread_from_lwp (ptid_t ptid
)
263 if (GET_LWP (ptid
) == 0)
264 ptid
= BUILD_LWP (GET_PID (ptid
), GET_PID (ptid
));
266 gdb_assert (is_lwp (ptid
));
268 err
= td_ta_map_lwp2thr_p (thread_agent
, GET_LWP (ptid
), &th
);
270 error ("Cannot find user-level thread for LWP %d: %s",
271 GET_LWP (ptid
), thread_db_err_str (err
));
273 err
= td_thr_get_info_p (&th
, &ti
);
275 error ("Cannot get thread info: %s", thread_db_err_str (err
));
277 return BUILD_THREAD (ti
.ti_tid
, GET_PID (ptid
));
281 lwp_from_thread (ptid_t ptid
)
287 if (! is_thread (ptid
))
290 err
= td_ta_map_id2thr_p (thread_agent
, GET_THREAD (ptid
), &th
);
292 error ("Cannot find thread %ld: %s",
293 (long) GET_THREAD (ptid
), thread_db_err_str (err
));
295 err
= td_thr_get_info_p (&th
, &ti
);
297 error ("Cannot get thread info: %s", thread_db_err_str (err
));
299 return BUILD_LWP (ti
.ti_lid
, GET_PID (ptid
));
304 thread_db_init (struct target_ops
*target
)
306 target_beneath
= target
;
310 thread_db_load (void)
315 handle
= dlopen (LIBTHREAD_DB_SO
, RTLD_NOW
);
319 /* Initialize pointers to the dynamic library functions we will use.
320 Essential functions first. */
322 td_init_p
= dlsym (handle
, "td_init");
323 if (td_init_p
== NULL
)
326 td_ta_new_p
= dlsym (handle
, "td_ta_new");
327 if (td_ta_new_p
== NULL
)
330 td_ta_map_id2thr_p
= dlsym (handle
, "td_ta_map_id2thr");
331 if (td_ta_map_id2thr_p
== NULL
)
334 td_ta_map_lwp2thr_p
= dlsym (handle
, "td_ta_map_lwp2thr");
335 if (td_ta_map_lwp2thr_p
== NULL
)
338 td_ta_thr_iter_p
= dlsym (handle
, "td_ta_thr_iter");
339 if (td_ta_thr_iter_p
== NULL
)
342 td_thr_validate_p
= dlsym (handle
, "td_thr_validate");
343 if (td_thr_validate_p
== NULL
)
346 td_thr_get_info_p
= dlsym (handle
, "td_thr_get_info");
347 if (td_thr_get_info_p
== NULL
)
350 td_thr_getfpregs_p
= dlsym (handle
, "td_thr_getfpregs");
351 if (td_thr_getfpregs_p
== NULL
)
354 td_thr_getgregs_p
= dlsym (handle
, "td_thr_getgregs");
355 if (td_thr_getgregs_p
== NULL
)
358 td_thr_setfpregs_p
= dlsym (handle
, "td_thr_setfpregs");
359 if (td_thr_setfpregs_p
== NULL
)
362 td_thr_setgregs_p
= dlsym (handle
, "td_thr_setgregs");
363 if (td_thr_setgregs_p
== NULL
)
366 /* Initialize the library. */
370 warning ("Cannot initialize libthread_db: %s", thread_db_err_str (err
));
374 /* These are not essential. */
375 td_ta_event_addr_p
= dlsym (handle
, "td_ta_event_addr");
376 td_ta_set_event_p
= dlsym (handle
, "td_ta_set_event");
377 td_ta_event_getmsg_p
= dlsym (handle
, "td_ta_event_getmsg");
378 td_thr_event_enable_p
= dlsym (handle
, "td_thr_event_enable");
384 enable_thread_event_reporting (void)
386 td_thr_events_t events
;
390 /* We cannot use the thread event reporting facility if these
391 functions aren't available. */
392 if (td_ta_event_addr_p
== NULL
|| td_ta_set_event_p
== NULL
393 || td_ta_event_getmsg_p
== NULL
|| td_thr_event_enable_p
== NULL
)
396 /* Set the process wide mask saying which events we're interested in. */
397 td_event_emptyset (&events
);
398 td_event_addset (&events
, TD_CREATE
);
400 /* FIXME: kettenis/2000-04-23: The event reporting facility is
401 broken for TD_DEATH events in glibc 2.1.3, so don't enable it for
403 td_event_addset (&events
, TD_DEATH
);
406 err
= td_ta_set_event_p (thread_agent
, &events
);
409 warning ("Unable to set global thread event mask: %s",
410 thread_db_err_str (err
));
414 /* Delete previous thread event breakpoints, if any. */
415 remove_thread_event_breakpoints ();
417 /* Get address for thread creation breakpoint. */
418 err
= td_ta_event_addr_p (thread_agent
, TD_CREATE
, ¬ify
);
421 warning ("Unable to get location for thread creation breakpoint: %s",
422 thread_db_err_str (err
));
426 /* Set up the breakpoint. */
427 td_create_bp_addr
= (CORE_ADDR
) notify
.u
.bptaddr
;
428 create_thread_event_breakpoint (td_create_bp_addr
);
430 /* Get address for thread death breakpoint. */
431 err
= td_ta_event_addr_p (thread_agent
, TD_DEATH
, ¬ify
);
434 warning ("Unable to get location for thread creation breakpoint: %s",
435 thread_db_err_str (err
));
439 /* Set up the breakpoint. */
440 td_death_bp_addr
= (CORE_ADDR
) notify
.u
.bptaddr
;
441 create_thread_event_breakpoint (td_death_bp_addr
);
445 disable_thread_event_reporting (void)
447 td_thr_events_t events
;
449 /* Set the process wide mask saying we aren't interested in any
451 td_event_emptyset (&events
);
452 td_ta_set_event_p (thread_agent
, &events
);
454 /* Delete thread event breakpoints, if any. */
455 remove_thread_event_breakpoints ();
456 td_create_bp_addr
= 0;
457 td_death_bp_addr
= 0;
461 check_thread_signals (void)
463 #ifdef GET_THREAD_SIGNALS
464 if (! thread_signals
)
469 GET_THREAD_SIGNALS (&mask
);
470 sigemptyset (&thread_stop_set
);
471 sigemptyset (&thread_print_set
);
473 for (i
= 1; i
< NSIG
; i
++)
475 if (sigismember (&mask
, i
))
477 if (signal_stop_update (target_signal_from_host (i
), 0))
478 sigaddset (&thread_stop_set
, i
);
479 if (signal_print_update (target_signal_from_host (i
), 0))
480 sigaddset (&thread_print_set
, i
);
489 disable_thread_signals (void)
491 #ifdef GET_THREAD_SIGNALS
496 for (i
= 1; i
< NSIG
; i
++)
498 if (sigismember (&thread_stop_set
, i
))
499 signal_stop_update (target_signal_from_host (i
), 1);
500 if (sigismember (&thread_print_set
, i
))
501 signal_print_update (target_signal_from_host (i
), 1);
510 deactivate_target (void)
512 /* Forget about the child's process ID. We shouldn't need it
516 if (! keep_thread_db
)
519 unpush_target (&thread_db_ops
);
524 thread_db_new_objfile (struct objfile
*objfile
)
530 /* All symbols have been discarded. If the thread_db target is
531 active, deactivate it now, even if the application was linked
532 statically against the thread library. */
535 deactivate_target ();
541 /* Nothing to do. The thread library was already detected and the
542 target vector was already activated. */
545 /* Initialize the structure that identifies the child process. Note
546 that at this point there is no guarantee that we actually have a
548 proc_handle
.pid
= GET_PID (inferior_ptid
);
550 /* Now attempt to open a connection to the thread library. */
551 err
= td_ta_new_p (&proc_handle
, &thread_agent
);
555 /* No thread library was detected. */
559 /* The thread library was detected. Activate the thread_db target. */
560 push_target (&thread_db_ops
);
563 /* If the thread library was detected in the main symbol file
564 itself, we assume that the program was statically linked
565 against the thread library and well have to keep this
566 module's target vector activated until forever... Well, at
567 least until all symbols have been discarded anyway (see
569 if (objfile
== symfile_objfile
)
571 gdb_assert (proc_handle
.pid
== 0);
575 /* We can only poke around if there actually is a child process.
576 If there is no child process alive, postpone the steps below
577 until one has been created. */
578 if (proc_handle
.pid
!= 0)
580 enable_thread_event_reporting ();
581 thread_db_find_new_threads ();
586 warning ("Cannot initialize thread debugging library: %s",
587 thread_db_err_str (err
));
592 if (target_new_objfile_chain
)
593 target_new_objfile_chain (objfile
);
597 attach_thread (ptid_t ptid
, const td_thrhandle_t
*th_p
,
598 const td_thrinfo_t
*ti_p
, int verbose
)
600 struct thread_info
*tp
;
603 check_thread_signals ();
606 printf_unfiltered ("[New %s]\n", target_pid_to_str (ptid
));
608 /* Add the thread to GDB's thread list. */
609 tp
= add_thread (ptid
);
610 tp
->private = xmalloc (sizeof (struct private_thread_info
));
611 tp
->private->lwpid
= ti_p
->ti_lid
;
613 /* Under Linux, we have to attach to each and every thread. */
615 if (ti_p
->ti_lid
!= GET_PID (ptid
))
616 ATTACH_LWP (BUILD_LWP (ti_p
->ti_lid
, GET_PID (ptid
)), 0);
619 /* Enable thread event reporting for this thread. */
620 err
= td_thr_event_enable_p (th_p
, 1);
622 error ("Cannot enable thread event reporting for %s: %s",
623 target_pid_to_str (ptid
), thread_db_err_str (err
));
627 detach_thread (ptid_t ptid
, int verbose
)
630 printf_unfiltered ("[%s exited]\n", target_pid_to_str (ptid
));
634 thread_db_detach (char *args
, int from_tty
)
636 disable_thread_event_reporting ();
637 deactivate_target ();
639 target_beneath
->to_detach (args
, from_tty
);
643 thread_db_resume (ptid_t ptid
, int step
, enum target_signal signo
)
645 struct cleanup
*old_chain
= save_inferior_ptid ();
647 if (GET_PID (ptid
) == -1)
648 inferior_ptid
= lwp_from_thread (inferior_ptid
);
649 else if (is_thread (ptid
))
650 ptid
= lwp_from_thread (ptid
);
652 target_beneath
->to_resume (ptid
, step
, signo
);
654 do_cleanups (old_chain
);
657 /* Check if PID is currently stopped at the location of a thread event
658 breakpoint location. If it is, read the event message and act upon
662 check_event (ptid_t ptid
)
669 /* Bail out early if we're not at a thread event breakpoint. */
670 stop_pc
= read_pc_pid (ptid
) - DECR_PC_AFTER_BREAK
;
671 if (stop_pc
!= td_create_bp_addr
&& stop_pc
!= td_death_bp_addr
)
674 err
= td_ta_event_getmsg_p (thread_agent
, &msg
);
680 error ("Cannot get thread event message: %s", thread_db_err_str (err
));
683 err
= td_thr_get_info_p (msg
.th_p
, &ti
);
685 error ("Cannot get thread info: %s", thread_db_err_str (err
));
687 ptid
= BUILD_THREAD (ti
.ti_tid
, GET_PID (ptid
));
693 /* FIXME: kettenis/2000-08-26: Since we use td_ta_event_getmsg,
694 there is no guarantee that the breakpoint will match the
695 event. Should we use td_thr_event_getmsg instead? */
697 if (stop_pc
!= td_create_bp_addr
)
698 error ("Thread creation event doesn't match breakpoint.");
701 /* We may already know about this thread, for instance when the
702 user has issued the `info threads' command before the SIGTRAP
703 for hitting the thread creation breakpoint was reported. */
704 if (! in_thread_list (ptid
))
705 attach_thread (ptid
, msg
.th_p
, &ti
, 1);
710 /* FIXME: See TD_CREATE. */
712 if (stop_pc
!= td_death_bp_addr
)
713 error ("Thread death event doesn't match breakpoint.");
716 if (! in_thread_list (ptid
))
717 error ("Spurious thread death event.");
719 detach_thread (ptid
, 1);
723 error ("Spurious thread event.");
728 thread_db_wait (ptid_t ptid
, struct target_waitstatus
*ourstatus
)
730 extern ptid_t trap_ptid
;
732 if (GET_PID (ptid
) != -1 && is_thread (ptid
))
733 ptid
= lwp_from_thread (ptid
);
735 ptid
= target_beneath
->to_wait (ptid
, ourstatus
);
737 if (proc_handle
.pid
== 0)
738 /* The current child process isn't the actual multi-threaded
739 program yet, so don't try to do any special thread-specific
740 post-processing and bail out early. */
743 if (ourstatus
->kind
== TARGET_WAITKIND_EXITED
)
744 return pid_to_ptid (-1);
746 if (ourstatus
->kind
== TARGET_WAITKIND_STOPPED
747 && ourstatus
->value
.sig
== TARGET_SIGNAL_TRAP
)
748 /* Check for a thread event. */
751 if (!ptid_equal (trap_ptid
, null_ptid
))
752 trap_ptid
= thread_from_lwp (trap_ptid
);
754 return thread_from_lwp (ptid
);
758 thread_db_xfer_memory (CORE_ADDR memaddr
, char *myaddr
, int len
, int write
,
759 struct mem_attrib
*attrib
,
760 struct target_ops
*target
)
762 struct cleanup
*old_chain
= save_inferior_ptid ();
765 if (is_thread (inferior_ptid
))
767 /* FIXME: This seems to be necessary to make sure breakpoints
769 if (! target_thread_alive (inferior_ptid
))
770 inferior_ptid
= pid_to_ptid (GET_PID (inferior_ptid
));
772 inferior_ptid
= lwp_from_thread (inferior_ptid
);
775 xfer
= target_beneath
->to_xfer_memory (memaddr
, myaddr
, len
, write
, attrib
, target
);
777 do_cleanups (old_chain
);
782 thread_db_fetch_registers (int regno
)
786 gdb_prfpregset_t fpregset
;
789 if (! is_thread (inferior_ptid
))
791 /* Pass the request to the target beneath us. */
792 target_beneath
->to_fetch_registers (regno
);
796 err
= td_ta_map_id2thr_p (thread_agent
, GET_THREAD (inferior_ptid
), &th
);
798 error ("Cannot find thread %ld: %s",
799 (long) GET_THREAD (inferior_ptid
), thread_db_err_str (err
));
801 err
= td_thr_getgregs_p (&th
, gregset
);
803 error ("Cannot fetch general-purpose registers for thread %ld: %s",
804 (long) GET_THREAD (inferior_ptid
), thread_db_err_str (err
));
806 err
= td_thr_getfpregs_p (&th
, &fpregset
);
808 error ("Cannot get floating-point registers for thread %ld: %s",
809 (long) GET_THREAD (inferior_ptid
), thread_db_err_str (err
));
811 /* Note that we must call supply_gregset after calling the thread_db
812 routines because the thread_db routines call ps_lgetgregs and
813 friends which clobber GDB's register cache. */
814 supply_gregset ((gdb_gregset_t
*) gregset
);
815 supply_fpregset (&fpregset
);
819 thread_db_store_registers (int regno
)
823 gdb_prfpregset_t fpregset
;
826 if (! is_thread (inferior_ptid
))
828 /* Pass the request to the target beneath us. */
829 target_beneath
->to_store_registers (regno
);
833 err
= td_ta_map_id2thr_p (thread_agent
, GET_THREAD (inferior_ptid
), &th
);
835 error ("Cannot find thread %ld: %s",
836 (long) GET_THREAD (inferior_ptid
), thread_db_err_str (err
));
840 char raw
[MAX_REGISTER_RAW_SIZE
];
842 read_register_gen (regno
, raw
);
843 thread_db_fetch_registers (-1);
844 supply_register (regno
, raw
);
847 fill_gregset ((gdb_gregset_t
*) gregset
, -1);
848 fill_fpregset (&fpregset
, -1);
850 err
= td_thr_setgregs_p (&th
, gregset
);
852 error ("Cannot store general-purpose registers for thread %ld: %s",
853 (long) GET_THREAD (inferior_ptid
), thread_db_err_str (err
));
854 err
= td_thr_setfpregs_p (&th
, &fpregset
);
856 error ("Cannot store floating-point registers for thread %ld: %s",
857 (long) GET_THREAD (inferior_ptid
), thread_db_err_str (err
));
861 thread_db_kill (void)
863 target_beneath
->to_kill ();
867 thread_db_create_inferior (char *exec_file
, char *allargs
, char **env
)
869 target_beneath
->to_create_inferior (exec_file
, allargs
, env
);
873 thread_db_post_startup_inferior (ptid_t ptid
)
875 if (proc_handle
.pid
== 0)
877 /* The child process is now the actual multi-threaded
878 program. Snatch its process ID... */
879 proc_handle
.pid
= GET_PID (ptid
);
881 /* ...and perform the remaining initialization steps. */
882 enable_thread_event_reporting ();
883 thread_db_find_new_threads();
888 thread_db_mourn_inferior (void)
890 remove_thread_event_breakpoints ();
891 deactivate_target ();
893 target_beneath
->to_mourn_inferior ();
897 thread_db_thread_alive (ptid_t ptid
)
899 if (is_thread (ptid
))
904 err
= td_ta_map_id2thr_p (thread_agent
, GET_THREAD (ptid
), &th
);
908 err
= td_thr_validate_p (&th
);
915 if (target_beneath
->to_thread_alive
)
916 return target_beneath
->to_thread_alive (ptid
);
922 find_new_threads_callback (const td_thrhandle_t
*th_p
, void *data
)
928 err
= td_thr_get_info_p (th_p
, &ti
);
930 error ("Cannot get thread info: %s", thread_db_err_str (err
));
932 ptid
= BUILD_THREAD (ti
.ti_tid
, GET_PID (inferior_ptid
));
934 if (! in_thread_list (ptid
))
935 attach_thread (ptid
, th_p
, &ti
, 1);
941 thread_db_find_new_threads (void)
945 /* Iterate over all user-space threads to discover new threads. */
946 err
= td_ta_thr_iter_p (thread_agent
, find_new_threads_callback
, NULL
,
947 TD_THR_ANY_STATE
, TD_THR_LOWEST_PRIORITY
,
948 TD_SIGNO_MASK
, TD_THR_ANY_USER_FLAGS
);
950 error ("Cannot find new threads: %s", thread_db_err_str (err
));
954 thread_db_pid_to_str (ptid_t ptid
)
956 if (is_thread (ptid
))
963 err
= td_ta_map_id2thr_p (thread_agent
, GET_THREAD (ptid
), &th
);
965 error ("Cannot find thread %ld: %s",
966 (long) GET_THREAD (ptid
), thread_db_err_str (err
));
968 err
= td_thr_get_info_p (&th
, &ti
);
970 error ("Cannot get thread info for thread %ld: %s",
971 (long) GET_THREAD (ptid
), thread_db_err_str (err
));
973 if (ti
.ti_state
== TD_THR_ACTIVE
&& ti
.ti_lid
!= 0)
975 snprintf (buf
, sizeof (buf
), "Thread %ld (LWP %d)",
976 (long) ti
.ti_tid
, ti
.ti_lid
);
980 snprintf (buf
, sizeof (buf
), "Thread %ld (%s)",
981 (long) ti
.ti_tid
, thread_db_state_str (ti
.ti_state
));
987 if (target_beneath
->to_pid_to_str (ptid
))
988 return target_beneath
->to_pid_to_str (ptid
);
990 return normal_pid_to_str (ptid
);
994 init_thread_db_ops (void)
996 thread_db_ops
.to_shortname
= "multi-thread";
997 thread_db_ops
.to_longname
= "multi-threaded child process.";
998 thread_db_ops
.to_doc
= "Threads and pthreads support.";
999 thread_db_ops
.to_detach
= thread_db_detach
;
1000 thread_db_ops
.to_resume
= thread_db_resume
;
1001 thread_db_ops
.to_wait
= thread_db_wait
;
1002 thread_db_ops
.to_fetch_registers
= thread_db_fetch_registers
;
1003 thread_db_ops
.to_store_registers
= thread_db_store_registers
;
1004 thread_db_ops
.to_xfer_memory
= thread_db_xfer_memory
;
1005 thread_db_ops
.to_kill
= thread_db_kill
;
1006 thread_db_ops
.to_create_inferior
= thread_db_create_inferior
;
1007 thread_db_ops
.to_post_startup_inferior
= thread_db_post_startup_inferior
;
1008 thread_db_ops
.to_mourn_inferior
= thread_db_mourn_inferior
;
1009 thread_db_ops
.to_thread_alive
= thread_db_thread_alive
;
1010 thread_db_ops
.to_find_new_threads
= thread_db_find_new_threads
;
1011 thread_db_ops
.to_pid_to_str
= thread_db_pid_to_str
;
1012 thread_db_ops
.to_stratum
= thread_stratum
;
1013 thread_db_ops
.to_has_thread_control
= tc_schedlock
;
1014 thread_db_ops
.to_magic
= OPS_MAGIC
;
1018 _initialize_thread_db (void)
1020 /* Only initialize the module if we can load libthread_db. */
1021 if (thread_db_load ())
1023 init_thread_db_ops ();
1024 add_target (&thread_db_ops
);
1026 /* Add ourselves to objfile event chain. */
1027 target_new_objfile_chain
= target_new_objfile_hook
;
1028 target_new_objfile_hook
= thread_db_new_objfile
;