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 have to keep this module's target vector active
61 static int keep_thread_db
;
63 /* Non-zero if we have determined the signals used by the threads
65 static int thread_signals
;
66 static sigset_t thread_stop_set
;
67 static sigset_t thread_print_set
;
69 /* Structure that identifies the child process for the
70 <proc_service.h> interface. */
71 static struct ps_prochandle proc_handle
;
73 /* Connection to the libthread_db library. */
74 static td_thragent_t
*thread_agent
;
76 /* Pointers to the libthread_db functions. */
78 static td_err_e (*td_init_p
) (void);
80 static td_err_e (*td_ta_new_p
) (struct ps_prochandle
*ps
, td_thragent_t
**ta
);
81 static td_err_e (*td_ta_map_id2thr_p
) (const td_thragent_t
*ta
, thread_t pt
,
82 td_thrhandle_t
*__th
);
83 static td_err_e (*td_ta_map_lwp2thr_p
) (const td_thragent_t
*ta
, lwpid_t lwpid
,
85 static td_err_e (*td_ta_thr_iter_p
) (const td_thragent_t
*ta
,
86 td_thr_iter_f
*callback
,
87 void *cbdata_p
, td_thr_state_e state
,
88 int ti_pri
, sigset_t
*ti_sigmask_p
,
89 unsigned int ti_user_flags
);
90 static td_err_e (*td_ta_event_addr_p
) (const td_thragent_t
*ta
,
91 td_event_e event
, td_notify_t
*ptr
);
92 static td_err_e (*td_ta_set_event_p
) (const td_thragent_t
*ta
,
93 td_thr_events_t
*event
);
94 static td_err_e (*td_ta_event_getmsg_p
) (const td_thragent_t
*ta
,
97 static td_err_e (*td_thr_validate_p
) (const td_thrhandle_t
*th
);
98 static td_err_e (*td_thr_get_info_p
) (const td_thrhandle_t
*th
,
100 static td_err_e (*td_thr_getfpregs_p
) (const td_thrhandle_t
*th
,
101 gdb_prfpregset_t
*regset
);
102 static td_err_e (*td_thr_getgregs_p
) (const td_thrhandle_t
*th
,
104 static td_err_e (*td_thr_setfpregs_p
) (const td_thrhandle_t
*th
,
105 const gdb_prfpregset_t
*fpregs
);
106 static td_err_e (*td_thr_setgregs_p
) (const td_thrhandle_t
*th
,
108 static td_err_e (*td_thr_event_enable_p
) (const td_thrhandle_t
*th
, int event
);
110 /* Location of the thread creation event breakpoint. The code at this
111 location in the child process will be called by the pthread library
112 whenever a new thread is created. By setting a special breakpoint
113 at this location, GDB can detect when a new thread is created. We
114 obtain this location via the td_ta_event_addr call. */
115 static CORE_ADDR td_create_bp_addr
;
117 /* Location of the thread death event breakpoint. */
118 static CORE_ADDR td_death_bp_addr
;
120 /* Prototypes for local functions. */
121 static void thread_db_find_new_threads (void);
124 /* Building process ids. */
127 #define GET_PID(ptid) ptid_get_pid (ptid)
128 #define GET_LWP(ptid) ptid_get_lwp (ptid)
129 #define GET_THREAD(ptid) ptid_get_tid (ptid)
131 #define is_lwp(ptid) (GET_LWP (ptid) != 0)
132 #define is_thread(ptid) (GET_THREAD (ptid) != 0)
134 #define BUILD_LWP(lwp, pid) ptid_build (pid, lwp, 0)
135 #define BUILD_THREAD(tid, pid) ptid_build (pid, 0, tid)
139 struct private_thread_info
141 /* Cached LWP id. Must come first, see lin-lwp.c. */
147 thread_db_err_str (td_err_e err
)
154 return "generic 'call succeeded'";
156 return "generic error";
158 return "no thread to satisfy query";
160 return "no sync handle to satisfy query";
162 return "no LWP to satisfy query";
164 return "invalid process handle";
166 return "invalid thread handle";
168 return "invalid synchronization handle";
170 return "invalid thread agent";
172 return "invalid key";
174 return "no event message for getmsg";
176 return "FPU register set not available";
178 return "application not linked with libthread";
180 return "requested event is not supported";
182 return "capability not available";
184 return "debugger service failed";
186 return "operation not applicable to";
188 return "no thread-specific data for this thread";
190 return "malloc failed";
192 return "only part of register set was written/read";
194 return "X register set not available for this thread";
196 snprintf (buf
, sizeof (buf
), "unknown thread_db error '%d'", err
);
202 thread_db_state_str (td_thr_state_e state
)
209 return "stopped by debugger";
218 case TD_THR_STOPPED_ASLEEP
:
219 return "stopped by debugger AND blocked";
221 snprintf (buf
, sizeof (buf
), "unknown thread_db state %d", state
);
227 /* Convert between user-level thread ids and LWP ids. */
230 thread_from_lwp (ptid_t ptid
)
236 if (GET_LWP (ptid
) == 0)
237 ptid
= BUILD_LWP (GET_PID (ptid
), GET_PID (ptid
));
239 gdb_assert (is_lwp (ptid
));
241 err
= td_ta_map_lwp2thr_p (thread_agent
, GET_LWP (ptid
), &th
);
243 error ("Cannot find user-level thread for LWP %d: %s",
244 GET_LWP (ptid
), thread_db_err_str (err
));
246 err
= td_thr_get_info_p (&th
, &ti
);
248 error ("Cannot get thread info: %s", thread_db_err_str (err
));
250 return BUILD_THREAD (ti
.ti_tid
, GET_PID (ptid
));
254 lwp_from_thread (ptid_t ptid
)
260 if (! is_thread (ptid
))
263 err
= td_ta_map_id2thr_p (thread_agent
, GET_THREAD (ptid
), &th
);
265 error ("Cannot find thread %ld: %s",
266 (long) GET_THREAD (ptid
), thread_db_err_str (err
));
268 err
= td_thr_get_info_p (&th
, &ti
);
270 error ("Cannot get thread info: %s", thread_db_err_str (err
));
272 return BUILD_LWP (ti
.ti_lid
, GET_PID (ptid
));
277 thread_db_init (struct target_ops
*target
)
279 target_beneath
= target
;
283 thread_db_load (void)
288 handle
= dlopen (LIBTHREAD_DB_SO
, RTLD_NOW
);
292 /* Initialize pointers to the dynamic library functions we will use.
293 Essential functions first. */
295 td_init_p
= dlsym (handle
, "td_init");
296 if (td_init_p
== NULL
)
299 td_ta_new_p
= dlsym (handle
, "td_ta_new");
300 if (td_ta_new_p
== NULL
)
303 td_ta_map_id2thr_p
= dlsym (handle
, "td_ta_map_id2thr");
304 if (td_ta_map_id2thr_p
== NULL
)
307 td_ta_map_lwp2thr_p
= dlsym (handle
, "td_ta_map_lwp2thr");
308 if (td_ta_map_lwp2thr_p
== NULL
)
311 td_ta_thr_iter_p
= dlsym (handle
, "td_ta_thr_iter");
312 if (td_ta_thr_iter_p
== NULL
)
315 td_thr_validate_p
= dlsym (handle
, "td_thr_validate");
316 if (td_thr_validate_p
== NULL
)
319 td_thr_get_info_p
= dlsym (handle
, "td_thr_get_info");
320 if (td_thr_get_info_p
== NULL
)
323 td_thr_getfpregs_p
= dlsym (handle
, "td_thr_getfpregs");
324 if (td_thr_getfpregs_p
== NULL
)
327 td_thr_getgregs_p
= dlsym (handle
, "td_thr_getgregs");
328 if (td_thr_getgregs_p
== NULL
)
331 td_thr_setfpregs_p
= dlsym (handle
, "td_thr_setfpregs");
332 if (td_thr_setfpregs_p
== NULL
)
335 td_thr_setgregs_p
= dlsym (handle
, "td_thr_setgregs");
336 if (td_thr_setgregs_p
== NULL
)
339 /* Initialize the library. */
343 warning ("Cannot initialize libthread_db: %s", thread_db_err_str (err
));
347 /* These are not essential. */
348 td_ta_event_addr_p
= dlsym (handle
, "td_ta_event_addr");
349 td_ta_set_event_p
= dlsym (handle
, "td_ta_set_event");
350 td_ta_event_getmsg_p
= dlsym (handle
, "td_ta_event_getmsg");
351 td_thr_event_enable_p
= dlsym (handle
, "td_thr_event_enable");
357 enable_thread_event_reporting (void)
359 td_thr_events_t events
;
363 /* We cannot use the thread event reporting facility if these
364 functions aren't available. */
365 if (td_ta_event_addr_p
== NULL
|| td_ta_set_event_p
== NULL
366 || td_ta_event_getmsg_p
== NULL
|| td_thr_event_enable_p
== NULL
)
369 /* Set the process wide mask saying which events we're interested in. */
370 td_event_emptyset (&events
);
371 td_event_addset (&events
, TD_CREATE
);
373 /* FIXME: kettenis/2000-04-23: The event reporting facility is
374 broken for TD_DEATH events in glibc 2.1.3, so don't enable it for
376 td_event_addset (&events
, TD_DEATH
);
379 err
= td_ta_set_event_p (thread_agent
, &events
);
382 warning ("Unable to set global thread event mask: %s",
383 thread_db_err_str (err
));
387 /* Delete previous thread event breakpoints, if any. */
388 remove_thread_event_breakpoints ();
390 /* Get address for thread creation breakpoint. */
391 err
= td_ta_event_addr_p (thread_agent
, TD_CREATE
, ¬ify
);
394 warning ("Unable to get location for thread creation breakpoint: %s",
395 thread_db_err_str (err
));
399 /* Set up the breakpoint. */
400 td_create_bp_addr
= (CORE_ADDR
) notify
.u
.bptaddr
;
401 create_thread_event_breakpoint (td_create_bp_addr
);
403 /* Get address for thread death breakpoint. */
404 err
= td_ta_event_addr_p (thread_agent
, TD_DEATH
, ¬ify
);
407 warning ("Unable to get location for thread creation breakpoint: %s",
408 thread_db_err_str (err
));
412 /* Set up the breakpoint. */
413 td_death_bp_addr
= (CORE_ADDR
) notify
.u
.bptaddr
;
414 create_thread_event_breakpoint (td_death_bp_addr
);
418 disable_thread_event_reporting (void)
420 td_thr_events_t events
;
422 /* Set the process wide mask saying we aren't interested in any
424 td_event_emptyset (&events
);
425 td_ta_set_event_p (thread_agent
, &events
);
427 /* Delete thread event breakpoints, if any. */
428 remove_thread_event_breakpoints ();
429 td_create_bp_addr
= 0;
430 td_death_bp_addr
= 0;
434 check_thread_signals (void)
436 #ifdef GET_THREAD_SIGNALS
437 if (! thread_signals
)
442 GET_THREAD_SIGNALS (&mask
);
443 sigemptyset (&thread_stop_set
);
444 sigemptyset (&thread_print_set
);
446 for (i
= 1; i
< NSIG
; i
++)
448 if (sigismember (&mask
, i
))
450 if (signal_stop_update (target_signal_from_host (i
), 0))
451 sigaddset (&thread_stop_set
, i
);
452 if (signal_print_update (target_signal_from_host (i
), 0))
453 sigaddset (&thread_print_set
, i
);
462 disable_thread_signals (void)
464 #ifdef GET_THREAD_SIGNALS
469 for (i
= 1; i
< NSIG
; i
++)
471 if (sigismember (&thread_stop_set
, i
))
472 signal_stop_update (target_signal_from_host (i
), 1);
473 if (sigismember (&thread_print_set
, i
))
474 signal_print_update (target_signal_from_host (i
), 1);
483 thread_db_new_objfile (struct objfile
*objfile
)
489 /* All symbols have been discarded. If the thread_db target is
490 active, deactivate it now. */
493 gdb_assert (proc_handle
.pid
== 0);
494 unpush_target (&thread_db_ops
);
504 /* Nothing to do. The thread library was already detected and the
505 target vector was already activated. */
508 /* Initialize the structure that identifies the child process. Note
509 that at this point there is no guarantee that we actually have a
511 proc_handle
.pid
= GET_PID (inferior_ptid
);
513 /* Now attempt to open a connection to the thread library. */
514 err
= td_ta_new_p (&proc_handle
, &thread_agent
);
518 /* No thread library was detected. */
522 /* The thread library was detected. Activate the thread_db target. */
523 push_target (&thread_db_ops
);
526 /* If the thread library was detected in the main symbol file
527 itself, we assume that the program was statically linked
528 against the thread library and well have to keep this
529 module's target vector activated until forever... Well, at
530 least until all symbols have been discarded anyway (see
532 if (objfile
== symfile_objfile
)
534 gdb_assert (proc_handle
.pid
== 0);
538 /* We can only poke around if there actually is a child process.
539 If there is no child process alive, postpone the steps below
540 until one has been created. */
541 if (proc_handle
.pid
!= 0)
543 enable_thread_event_reporting ();
544 thread_db_find_new_threads ();
549 warning ("Cannot initialize thread debugging library: %s",
550 thread_db_err_str (err
));
555 if (target_new_objfile_chain
)
556 target_new_objfile_chain (objfile
);
560 attach_thread (ptid_t ptid
, const td_thrhandle_t
*th_p
,
561 const td_thrinfo_t
*ti_p
, int verbose
)
563 struct thread_info
*tp
;
566 check_thread_signals ();
569 printf_unfiltered ("[New %s]\n", target_pid_to_str (ptid
));
571 /* Add the thread to GDB's thread list. */
572 tp
= add_thread (ptid
);
573 tp
->private = xmalloc (sizeof (struct private_thread_info
));
574 tp
->private->lwpid
= ti_p
->ti_lid
;
576 if (ti_p
->ti_state
== TD_THR_UNKNOWN
)
577 return;/* A zombie thread that's been joined -- do not attach. */
579 /* Under Linux, we have to attach to each and every thread. */
581 ATTACH_LWP (BUILD_LWP (ti_p
->ti_lid
, GET_PID (ptid
)), 0);
584 /* Enable thread event reporting for this thread. */
585 err
= td_thr_event_enable_p (th_p
, 1);
587 error ("Cannot enable thread event reporting for %s: %s",
588 target_pid_to_str (ptid
), thread_db_err_str (err
));
592 thread_db_attach (char *args
, int from_tty
)
594 target_beneath
->to_attach (args
, from_tty
);
596 /* Destroy thread info; it's no longer valid. */
599 /* The child process is now the actual multi-threaded
600 program. Snatch its process ID... */
601 proc_handle
.pid
= GET_PID (inferior_ptid
);
603 /* ...and perform the remaining initialization steps. */
604 enable_thread_event_reporting ();
605 thread_db_find_new_threads();
609 detach_thread (ptid_t ptid
, int verbose
)
612 printf_unfiltered ("[%s exited]\n", target_pid_to_str (ptid
));
616 thread_db_detach (char *args
, int from_tty
)
618 disable_thread_event_reporting ();
620 /* There's no need to save & restore inferior_ptid here, since the
621 inferior is supposed to be survive this function call. */
622 inferior_ptid
= lwp_from_thread (inferior_ptid
);
624 /* Forget about the child's process ID. We shouldn't need it
628 target_beneath
->to_detach (args
, from_tty
);
632 thread_db_resume (ptid_t ptid
, int step
, enum target_signal signo
)
634 struct cleanup
*old_chain
= save_inferior_ptid ();
636 if (GET_PID (ptid
) == -1)
637 inferior_ptid
= lwp_from_thread (inferior_ptid
);
638 else if (is_thread (ptid
))
639 ptid
= lwp_from_thread (ptid
);
641 target_beneath
->to_resume (ptid
, step
, signo
);
643 do_cleanups (old_chain
);
646 /* Check if PID is currently stopped at the location of a thread event
647 breakpoint location. If it is, read the event message and act upon
651 check_event (ptid_t ptid
)
658 /* Bail out early if we're not at a thread event breakpoint. */
659 stop_pc
= read_pc_pid (ptid
) - DECR_PC_AFTER_BREAK
;
660 if (stop_pc
!= td_create_bp_addr
&& stop_pc
!= td_death_bp_addr
)
663 err
= td_ta_event_getmsg_p (thread_agent
, &msg
);
669 error ("Cannot get thread event message: %s", thread_db_err_str (err
));
672 err
= td_thr_get_info_p (msg
.th_p
, &ti
);
674 error ("Cannot get thread info: %s", thread_db_err_str (err
));
676 ptid
= BUILD_THREAD (ti
.ti_tid
, GET_PID (ptid
));
682 /* FIXME: kettenis/2000-08-26: Since we use td_ta_event_getmsg,
683 there is no guarantee that the breakpoint will match the
684 event. Should we use td_thr_event_getmsg instead? */
686 if (stop_pc
!= td_create_bp_addr
)
687 error ("Thread creation event doesn't match breakpoint.");
690 /* We may already know about this thread, for instance when the
691 user has issued the `info threads' command before the SIGTRAP
692 for hitting the thread creation breakpoint was reported. */
693 if (! in_thread_list (ptid
))
694 attach_thread (ptid
, msg
.th_p
, &ti
, 1);
699 /* FIXME: See TD_CREATE. */
701 if (stop_pc
!= td_death_bp_addr
)
702 error ("Thread death event doesn't match breakpoint.");
705 if (! in_thread_list (ptid
))
706 error ("Spurious thread death event.");
708 detach_thread (ptid
, 1);
712 error ("Spurious thread event.");
717 thread_db_wait (ptid_t ptid
, struct target_waitstatus
*ourstatus
)
719 extern ptid_t trap_ptid
;
721 if (GET_PID (ptid
) != -1 && is_thread (ptid
))
722 ptid
= lwp_from_thread (ptid
);
724 ptid
= target_beneath
->to_wait (ptid
, ourstatus
);
726 if (proc_handle
.pid
== 0)
727 /* The current child process isn't the actual multi-threaded
728 program yet, so don't try to do any special thread-specific
729 post-processing and bail out early. */
732 if (ourstatus
->kind
== TARGET_WAITKIND_EXITED
)
733 return pid_to_ptid (-1);
735 if (ourstatus
->kind
== TARGET_WAITKIND_STOPPED
736 && ourstatus
->value
.sig
== TARGET_SIGNAL_TRAP
)
737 /* Check for a thread event. */
740 if (!ptid_equal (trap_ptid
, null_ptid
))
741 trap_ptid
= thread_from_lwp (trap_ptid
);
743 return thread_from_lwp (ptid
);
747 thread_db_xfer_memory (CORE_ADDR memaddr
, char *myaddr
, int len
, int write
,
748 struct mem_attrib
*attrib
,
749 struct target_ops
*target
)
751 struct cleanup
*old_chain
= save_inferior_ptid ();
754 if (is_thread (inferior_ptid
))
756 /* FIXME: This seems to be necessary to make sure breakpoints
758 if (! target_thread_alive (inferior_ptid
))
759 inferior_ptid
= pid_to_ptid (GET_PID (inferior_ptid
));
761 inferior_ptid
= lwp_from_thread (inferior_ptid
);
764 xfer
= target_beneath
->to_xfer_memory (memaddr
, myaddr
, len
, write
, attrib
, target
);
766 do_cleanups (old_chain
);
771 thread_db_fetch_registers (int regno
)
775 gdb_prfpregset_t fpregset
;
778 if (! is_thread (inferior_ptid
))
780 /* Pass the request to the target beneath us. */
781 target_beneath
->to_fetch_registers (regno
);
785 err
= td_ta_map_id2thr_p (thread_agent
, GET_THREAD (inferior_ptid
), &th
);
787 error ("Cannot find thread %ld: %s",
788 (long) GET_THREAD (inferior_ptid
), thread_db_err_str (err
));
790 err
= td_thr_getgregs_p (&th
, gregset
);
792 error ("Cannot fetch general-purpose registers for thread %ld: %s",
793 (long) GET_THREAD (inferior_ptid
), thread_db_err_str (err
));
795 err
= td_thr_getfpregs_p (&th
, &fpregset
);
797 error ("Cannot get floating-point registers for thread %ld: %s",
798 (long) GET_THREAD (inferior_ptid
), thread_db_err_str (err
));
800 /* Note that we must call supply_gregset after calling the thread_db
801 routines because the thread_db routines call ps_lgetgregs and
802 friends which clobber GDB's register cache. */
803 supply_gregset ((gdb_gregset_t
*) gregset
);
804 supply_fpregset (&fpregset
);
808 thread_db_store_registers (int regno
)
812 gdb_prfpregset_t fpregset
;
815 if (! is_thread (inferior_ptid
))
817 /* Pass the request to the target beneath us. */
818 target_beneath
->to_store_registers (regno
);
822 err
= td_ta_map_id2thr_p (thread_agent
, GET_THREAD (inferior_ptid
), &th
);
824 error ("Cannot find thread %ld: %s",
825 (long) GET_THREAD (inferior_ptid
), thread_db_err_str (err
));
829 char raw
[MAX_REGISTER_RAW_SIZE
];
831 read_register_gen (regno
, raw
);
832 thread_db_fetch_registers (-1);
833 supply_register (regno
, raw
);
836 fill_gregset ((gdb_gregset_t
*) gregset
, -1);
837 fill_fpregset (&fpregset
, -1);
839 err
= td_thr_setgregs_p (&th
, gregset
);
841 error ("Cannot store general-purpose registers for thread %ld: %s",
842 (long) GET_THREAD (inferior_ptid
), thread_db_err_str (err
));
843 err
= td_thr_setfpregs_p (&th
, &fpregset
);
845 error ("Cannot store floating-point registers for thread %ld: %s",
846 (long) GET_THREAD (inferior_ptid
), thread_db_err_str (err
));
850 thread_db_kill (void)
852 /* There's no need to save & restore inferior_ptid here, since the
853 inferior isn't supposed to survive this function call. */
854 inferior_ptid
= lwp_from_thread (inferior_ptid
);
855 target_beneath
->to_kill ();
859 thread_db_create_inferior (char *exec_file
, char *allargs
, char **env
)
861 if (! keep_thread_db
)
863 unpush_target (&thread_db_ops
);
867 target_beneath
->to_create_inferior (exec_file
, allargs
, env
);
871 thread_db_post_startup_inferior (ptid_t ptid
)
873 if (proc_handle
.pid
== 0)
875 /* The child process is now the actual multi-threaded
876 program. Snatch its process ID... */
877 proc_handle
.pid
= GET_PID (ptid
);
879 /* ...and perform the remaining initialization steps. */
880 enable_thread_event_reporting ();
881 thread_db_find_new_threads();
886 thread_db_mourn_inferior (void)
888 remove_thread_event_breakpoints ();
890 /* Forget about the child's process ID. We shouldn't need it
894 target_beneath
->to_mourn_inferior ();
898 thread_db_thread_alive (ptid_t ptid
)
904 if (is_thread (ptid
))
906 err
= td_ta_map_id2thr_p (thread_agent
, GET_THREAD (ptid
), &th
);
910 err
= td_thr_validate_p (&th
);
914 err
= td_thr_get_info_p (&th
, &ti
);
918 if (ti
.ti_state
== TD_THR_UNKNOWN
)
919 return 0; /* A zombie thread that's been joined. */
924 if (target_beneath
->to_thread_alive
)
925 return target_beneath
->to_thread_alive (ptid
);
931 find_new_threads_callback (const td_thrhandle_t
*th_p
, void *data
)
937 err
= td_thr_get_info_p (th_p
, &ti
);
939 error ("Cannot get thread info: %s", thread_db_err_str (err
));
941 if (ti
.ti_state
== TD_THR_UNKNOWN
)
942 return 0; /* A zombie that's been reaped -- ignore. */
944 ptid
= BUILD_THREAD (ti
.ti_tid
, GET_PID (inferior_ptid
));
946 if (! in_thread_list (ptid
))
947 attach_thread (ptid
, th_p
, &ti
, 1);
953 thread_db_find_new_threads (void)
957 /* Iterate over all user-space threads to discover new threads. */
958 err
= td_ta_thr_iter_p (thread_agent
, find_new_threads_callback
, NULL
,
959 TD_THR_ANY_STATE
, TD_THR_LOWEST_PRIORITY
,
960 TD_SIGNO_MASK
, TD_THR_ANY_USER_FLAGS
);
962 error ("Cannot find new threads: %s", thread_db_err_str (err
));
966 thread_db_pid_to_str (ptid_t ptid
)
968 if (is_thread (ptid
))
975 err
= td_ta_map_id2thr_p (thread_agent
, GET_THREAD (ptid
), &th
);
977 error ("Cannot find thread %ld: %s",
978 (long) GET_THREAD (ptid
), thread_db_err_str (err
));
980 err
= td_thr_get_info_p (&th
, &ti
);
982 error ("Cannot get thread info for thread %ld: %s",
983 (long) GET_THREAD (ptid
), thread_db_err_str (err
));
985 if (ti
.ti_state
== TD_THR_ACTIVE
&& ti
.ti_lid
!= 0)
987 snprintf (buf
, sizeof (buf
), "Thread %ld (LWP %d)",
988 (long) ti
.ti_tid
, ti
.ti_lid
);
992 snprintf (buf
, sizeof (buf
), "Thread %ld (%s)",
993 (long) ti
.ti_tid
, thread_db_state_str (ti
.ti_state
));
999 if (target_beneath
->to_pid_to_str (ptid
))
1000 return target_beneath
->to_pid_to_str (ptid
);
1002 return normal_pid_to_str (ptid
);
1006 init_thread_db_ops (void)
1008 thread_db_ops
.to_shortname
= "multi-thread";
1009 thread_db_ops
.to_longname
= "multi-threaded child process.";
1010 thread_db_ops
.to_doc
= "Threads and pthreads support.";
1011 thread_db_ops
.to_attach
= thread_db_attach
;
1012 thread_db_ops
.to_detach
= thread_db_detach
;
1013 thread_db_ops
.to_resume
= thread_db_resume
;
1014 thread_db_ops
.to_wait
= thread_db_wait
;
1015 thread_db_ops
.to_fetch_registers
= thread_db_fetch_registers
;
1016 thread_db_ops
.to_store_registers
= thread_db_store_registers
;
1017 thread_db_ops
.to_xfer_memory
= thread_db_xfer_memory
;
1018 thread_db_ops
.to_kill
= thread_db_kill
;
1019 thread_db_ops
.to_create_inferior
= thread_db_create_inferior
;
1020 thread_db_ops
.to_post_startup_inferior
= thread_db_post_startup_inferior
;
1021 thread_db_ops
.to_mourn_inferior
= thread_db_mourn_inferior
;
1022 thread_db_ops
.to_thread_alive
= thread_db_thread_alive
;
1023 thread_db_ops
.to_find_new_threads
= thread_db_find_new_threads
;
1024 thread_db_ops
.to_pid_to_str
= thread_db_pid_to_str
;
1025 thread_db_ops
.to_stratum
= thread_stratum
;
1026 thread_db_ops
.to_has_thread_control
= tc_schedlock
;
1027 thread_db_ops
.to_magic
= OPS_MAGIC
;
1031 _initialize_thread_db (void)
1033 /* Only initialize the module if we can load libthread_db. */
1034 if (thread_db_load ())
1036 init_thread_db_ops ();
1037 add_target (&thread_db_ops
);
1039 /* Add ourselves to objfile event chain. */
1040 target_new_objfile_chain
= target_new_objfile_hook
;
1041 target_new_objfile_hook
= thread_db_new_objfile
;