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 PIDGET(PID) (((PID) & 0xffff))
128 #define MERGEPID(PID, TID) (((PID) & 0xffff) | ((TID) << 16))
131 #define THREAD_FLAG 0x80000000
133 #define is_lwp(pid) (((pid) & THREAD_FLAG) == 0 && TIDGET (pid))
134 #define is_thread(pid) ((pid) & THREAD_FLAG)
136 #define GET_PID(pid) PIDGET (pid)
137 #define GET_LWP(pid) TIDGET (pid)
138 #define GET_THREAD(pid) TIDGET (pid)
140 #define BUILD_LWP(tid, pid) MERGEPID (pid, tid)
141 #define BUILD_THREAD(tid, pid) (MERGEPID (pid, tid) | THREAD_FLAG)
144 struct private_thread_info
146 /* Cached LWP id. Must come first, see lin-lwp.c. */
151 /* Helper functions. */
154 restore_inferior_pid (void *arg
)
156 int *saved_pid_ptr
= arg
;
157 inferior_pid
= *saved_pid_ptr
;
161 static struct cleanup
*
162 save_inferior_pid (void)
166 saved_pid_ptr
= xmalloc (sizeof (int));
167 *saved_pid_ptr
= inferior_pid
;
168 return make_cleanup (restore_inferior_pid
, saved_pid_ptr
);
173 thread_db_err_str (td_err_e err
)
180 return "generic 'call succeeded'";
182 return "generic error";
184 return "no thread to satisfy query";
186 return "no sync handle to satisfy query";
188 return "no LWP to satisfy query";
190 return "invalid process handle";
192 return "invalid thread handle";
194 return "invalid synchronization handle";
196 return "invalid thread agent";
198 return "invalid key";
200 return "no event message for getmsg";
202 return "FPU register set not available";
204 return "application not linked with libthread";
206 return "requested event is not supported";
208 return "capability not available";
210 return "debugger service failed";
212 return "operation not applicable to";
214 return "no thread-specific data for this thread";
216 return "malloc failed";
218 return "only part of register set was written/read";
220 return "X register set not available for this thread";
222 snprintf (buf
, sizeof (buf
), "unknown thread_db error '%d'", err
);
228 thread_db_state_str (td_thr_state_e state
)
235 return "stopped by debugger";
244 case TD_THR_STOPPED_ASLEEP
:
245 return "stopped by debugger AND blocked";
247 snprintf (buf
, sizeof (buf
), "unknown thread_db state %d", state
);
253 /* Convert between user-level thread ids and LWP ids. */
256 thread_from_lwp (int pid
)
262 if (GET_LWP (pid
) == 0)
263 pid
= BUILD_LWP (pid
, pid
);
265 gdb_assert (is_lwp (pid
));
267 err
= td_ta_map_lwp2thr_p (thread_agent
, GET_LWP (pid
), &th
);
269 error ("Cannot find user-level thread for LWP %d: %s",
270 GET_LWP (pid
), thread_db_err_str (err
));
272 err
= td_thr_get_info_p (&th
, &ti
);
274 error ("Cannot get thread info: %s", thread_db_err_str (err
));
276 return BUILD_THREAD (ti
.ti_tid
, GET_PID (pid
));
280 lwp_from_thread (int pid
)
286 if (! is_thread (pid
))
289 err
= td_ta_map_id2thr_p (thread_agent
, GET_THREAD (pid
), &th
);
291 error ("Cannot find thread %ld: %s",
292 (long) GET_THREAD (pid
), thread_db_err_str (err
));
294 err
= td_thr_get_info_p (&th
, &ti
);
296 error ("Cannot get thread info: %s", thread_db_err_str (err
));
298 return BUILD_LWP (ti
.ti_lid
, GET_PID (pid
));
303 thread_db_init (struct target_ops
*target
)
305 target_beneath
= target
;
309 thread_db_load (void)
314 handle
= dlopen (LIBTHREAD_DB_SO
, RTLD_NOW
);
318 /* Initialize pointers to the dynamic library functions we will use.
319 Essential functions first. */
321 td_init_p
= dlsym (handle
, "td_init");
322 if (td_init_p
== NULL
)
325 td_ta_new_p
= dlsym (handle
, "td_ta_new");
326 if (td_ta_new_p
== NULL
)
329 td_ta_map_id2thr_p
= dlsym (handle
, "td_ta_map_id2thr");
330 if (td_ta_map_id2thr_p
== NULL
)
333 td_ta_map_lwp2thr_p
= dlsym (handle
, "td_ta_map_lwp2thr");
334 if (td_ta_map_lwp2thr_p
== NULL
)
337 td_ta_thr_iter_p
= dlsym (handle
, "td_ta_thr_iter");
338 if (td_ta_thr_iter_p
== NULL
)
341 td_thr_validate_p
= dlsym (handle
, "td_thr_validate");
342 if (td_thr_validate_p
== NULL
)
345 td_thr_get_info_p
= dlsym (handle
, "td_thr_get_info");
346 if (td_thr_get_info_p
== NULL
)
349 td_thr_getfpregs_p
= dlsym (handle
, "td_thr_getfpregs");
350 if (td_thr_getfpregs_p
== NULL
)
353 td_thr_getgregs_p
= dlsym (handle
, "td_thr_getgregs");
354 if (td_thr_getgregs_p
== NULL
)
357 td_thr_setfpregs_p
= dlsym (handle
, "td_thr_setfpregs");
358 if (td_thr_setfpregs_p
== NULL
)
361 td_thr_setgregs_p
= dlsym (handle
, "td_thr_setgregs");
362 if (td_thr_setgregs_p
== NULL
)
365 /* Initialize the library. */
369 warning ("Cannot initialize libthread_db: %s", thread_db_err_str (err
));
373 /* These are not essential. */
374 td_ta_event_addr_p
= dlsym (handle
, "td_ta_event_addr");
375 td_ta_set_event_p
= dlsym (handle
, "td_ta_set_event");
376 td_ta_event_getmsg_p
= dlsym (handle
, "td_ta_event_getmsg");
377 td_thr_event_enable_p
= dlsym (handle
, "td_thr_event_enable");
383 enable_thread_event_reporting (void)
385 td_thr_events_t events
;
389 /* We cannot use the thread event reporting facility if these
390 functions aren't available. */
391 if (td_ta_event_addr_p
== NULL
|| td_ta_set_event_p
== NULL
392 || td_ta_event_getmsg_p
== NULL
|| td_thr_event_enable_p
== NULL
)
395 /* Set the process wide mask saying which events we're interested in. */
396 td_event_emptyset (&events
);
397 td_event_addset (&events
, TD_CREATE
);
399 /* FIXME: kettenis/2000-04-23: The event reporting facility is
400 broken for TD_DEATH events in glibc 2.1.3, so don't enable it for
402 td_event_addset (&events
, TD_DEATH
);
405 err
= td_ta_set_event_p (thread_agent
, &events
);
408 warning ("Unable to set global thread event mask: %s",
409 thread_db_err_str (err
));
413 /* Delete previous thread event breakpoints, if any. */
414 remove_thread_event_breakpoints ();
416 /* Get address for thread creation breakpoint. */
417 err
= td_ta_event_addr_p (thread_agent
, TD_CREATE
, ¬ify
);
420 warning ("Unable to get location for thread creation breakpoint: %s",
421 thread_db_err_str (err
));
425 /* Set up the breakpoint. */
426 td_create_bp_addr
= (CORE_ADDR
) notify
.u
.bptaddr
;
427 create_thread_event_breakpoint (td_create_bp_addr
);
429 /* Get address for thread death breakpoint. */
430 err
= td_ta_event_addr_p (thread_agent
, TD_DEATH
, ¬ify
);
433 warning ("Unable to get location for thread creation breakpoint: %s",
434 thread_db_err_str (err
));
438 /* Set up the breakpoint. */
439 td_death_bp_addr
= (CORE_ADDR
) notify
.u
.bptaddr
;
440 create_thread_event_breakpoint (td_death_bp_addr
);
444 disable_thread_event_reporting (void)
446 td_thr_events_t events
;
448 /* Set the process wide mask saying we aren't interested in any
450 td_event_emptyset (&events
);
451 td_ta_set_event_p (thread_agent
, &events
);
453 /* Delete thread event breakpoints, if any. */
454 remove_thread_event_breakpoints ();
455 td_create_bp_addr
= 0;
456 td_death_bp_addr
= 0;
460 check_thread_signals (void)
462 #ifdef GET_THREAD_SIGNALS
463 if (! thread_signals
)
468 GET_THREAD_SIGNALS (&mask
);
469 sigemptyset (&thread_stop_set
);
470 sigemptyset (&thread_print_set
);
472 for (i
= 1; i
< NSIG
; i
++)
474 if (sigismember (&mask
, i
))
476 if (signal_stop_update (target_signal_from_host (i
), 0))
477 sigaddset (&thread_stop_set
, i
);
478 if (signal_print_update (target_signal_from_host (i
), 0))
479 sigaddset (&thread_print_set
, i
);
488 disable_thread_signals (void)
490 #ifdef GET_THREAD_SIGNALS
495 for (i
= 1; i
< NSIG
; i
++)
497 if (sigismember (&thread_stop_set
, i
))
498 signal_stop_update (target_signal_from_host (i
), 1);
499 if (sigismember (&thread_print_set
, i
))
500 signal_print_update (target_signal_from_host (i
), 1);
509 deactivate_target (void)
511 /* Forget about the child's process ID. We shouldn't need it
515 if (! keep_thread_db
)
518 unpush_target (&thread_db_ops
);
523 thread_db_new_objfile (struct objfile
*objfile
)
529 /* All symbols have been discarded. If the thread_db target is
530 active, deactivate it now, even if the application was linked
531 statically against the thread library. */
534 deactivate_target ();
540 /* Nothing to do. The thread library was already detected and the
541 target vector was already activated. */
544 /* Initialize the structure that identifies the child process. Note
545 that at this point there is no guarantee that we actually have a
547 proc_handle
.pid
= GET_PID (inferior_pid
);
549 /* Now attempt to open a connection to the thread library. */
550 err
= td_ta_new_p (&proc_handle
, &thread_agent
);
554 /* No thread library was detected. */
558 /* The thread library was detected. Activate the thread_db target. */
559 push_target (&thread_db_ops
);
562 /* If the thread library was detected in the main symbol file
563 itself, we assume that the program was statically linked
564 against the thread library and well have to keep this
565 module's target vector activated until forever... Well, at
566 least until all symbols have been discarded anyway (see
568 if (objfile
== symfile_objfile
)
570 gdb_assert (proc_handle
.pid
== 0);
574 /* We can only poke around if there actually is a child process.
575 If there is no child process alive, postpone the steps below
576 until one has been created. */
577 if (proc_handle
.pid
!= 0)
579 enable_thread_event_reporting ();
580 thread_db_find_new_threads ();
585 warning ("Cannot initialize thread debugging library: %s",
586 thread_db_err_str (err
));
591 if (target_new_objfile_chain
)
592 target_new_objfile_chain (objfile
);
596 attach_thread (int pid
, const td_thrhandle_t
*th_p
,
597 const td_thrinfo_t
*ti_p
, int verbose
)
599 struct thread_info
*tp
;
602 check_thread_signals ();
605 printf_unfiltered ("[New %s]\n", target_pid_to_str (pid
));
607 /* Add the thread to GDB's thread list. */
608 tp
= add_thread (pid
);
609 tp
->private = xmalloc (sizeof (struct private_thread_info
));
610 tp
->private->lwpid
= ti_p
->ti_lid
;
612 /* Under Linux, we have to attach to each and every thread. */
614 if (ti_p
->ti_lid
!= GET_PID (pid
))
615 ATTACH_LWP (BUILD_LWP (ti_p
->ti_lid
, GET_PID (pid
)), 0);
618 /* Enable thread event reporting for this thread. */
619 err
= td_thr_event_enable_p (th_p
, 1);
621 error ("Cannot enable thread event reporting for %s: %s",
622 target_pid_to_str (pid
), thread_db_err_str (err
));
626 detach_thread (int pid
, int verbose
)
629 printf_unfiltered ("[%s exited]\n", target_pid_to_str (pid
));
633 thread_db_detach (char *args
, int from_tty
)
635 disable_thread_event_reporting ();
636 deactivate_target ();
638 target_beneath
->to_detach (args
, from_tty
);
642 thread_db_resume (int pid
, int step
, enum target_signal signo
)
644 struct cleanup
*old_chain
= save_inferior_pid ();
647 inferior_pid
= lwp_from_thread (inferior_pid
);
648 else if (is_thread (pid
))
649 pid
= lwp_from_thread (pid
);
651 target_beneath
->to_resume (pid
, step
, signo
);
653 do_cleanups (old_chain
);
656 /* Check if PID is currently stopped at the location of a thread event
657 breakpoint location. If it is, read the event message and act upon
661 check_event (int pid
)
668 /* Bail out early if we're not at a thread event breakpoint. */
669 stop_pc
= read_pc_pid (pid
) - DECR_PC_AFTER_BREAK
;
670 if (stop_pc
!= td_create_bp_addr
&& stop_pc
!= td_death_bp_addr
)
673 err
= td_ta_event_getmsg_p (thread_agent
, &msg
);
679 error ("Cannot get thread event message: %s", thread_db_err_str (err
));
682 err
= td_thr_get_info_p (msg
.th_p
, &ti
);
684 error ("Cannot get thread info: %s", thread_db_err_str (err
));
686 pid
= BUILD_THREAD (ti
.ti_tid
, GET_PID (pid
));
692 /* FIXME: kettenis/2000-08-26: Since we use td_ta_event_getmsg,
693 there is no guarantee that the breakpoint will match the
694 event. Should we use td_thr_event_getmsg instead? */
696 if (stop_pc
!= td_create_bp_addr
)
697 error ("Thread creation event doesn't match breakpoint.");
700 /* We may already know about this thread, for instance when the
701 user has issued the `info threads' command before the SIGTRAP
702 for hitting the thread creation breakpoint was reported. */
703 if (! in_thread_list (pid
))
704 attach_thread (pid
, msg
.th_p
, &ti
, 1);
709 /* FIXME: See TD_CREATE. */
711 if (stop_pc
!= td_death_bp_addr
)
712 error ("Thread death event doesn't match breakpoint.");
715 if (! in_thread_list (pid
))
716 error ("Spurious thread death event.");
718 detach_thread (pid
, 1);
722 error ("Spurious thread event.");
727 thread_db_wait (int pid
, struct target_waitstatus
*ourstatus
)
731 if (pid
!= -1 && is_thread (pid
))
732 pid
= lwp_from_thread (pid
);
734 pid
= target_beneath
->to_wait (pid
, ourstatus
);
736 if (proc_handle
.pid
== 0)
737 /* The current child process isn't the actual multi-threaded
738 program yet, so don't try to do any special thread-specific
739 post-processing and bail out early. */
742 if (ourstatus
->kind
== TARGET_WAITKIND_EXITED
)
745 if (ourstatus
->kind
== TARGET_WAITKIND_STOPPED
746 && ourstatus
->value
.sig
== TARGET_SIGNAL_TRAP
)
747 /* Check for a thread event. */
751 trap_pid
= thread_from_lwp (trap_pid
);
753 return thread_from_lwp (pid
);
757 thread_db_xfer_memory (CORE_ADDR memaddr
, char *myaddr
, int len
, int write
,
758 struct mem_attrib
*attrib
,
759 struct target_ops
*target
)
761 struct cleanup
*old_chain
= save_inferior_pid ();
764 if (is_thread (inferior_pid
))
766 /* FIXME: This seems to be necessary to make sure breakpoints
768 if (! target_thread_alive (inferior_pid
))
769 inferior_pid
= GET_PID (inferior_pid
);
771 inferior_pid
= lwp_from_thread (inferior_pid
);
774 xfer
= target_beneath
->to_xfer_memory (memaddr
, myaddr
, len
, write
, attrib
, target
);
776 do_cleanups (old_chain
);
781 thread_db_fetch_registers (int regno
)
785 gdb_prfpregset_t fpregset
;
788 if (! is_thread (inferior_pid
))
790 /* Pass the request to the target beneath us. */
791 target_beneath
->to_fetch_registers (regno
);
795 err
= td_ta_map_id2thr_p (thread_agent
, GET_THREAD (inferior_pid
), &th
);
797 error ("Cannot find thread %ld: %s",
798 (long) GET_THREAD (inferior_pid
), thread_db_err_str (err
));
800 err
= td_thr_getgregs_p (&th
, gregset
);
802 error ("Cannot fetch general-purpose registers for thread %ld: %s",
803 (long) GET_THREAD (inferior_pid
), thread_db_err_str (err
));
805 err
= td_thr_getfpregs_p (&th
, &fpregset
);
807 error ("Cannot get floating-point registers for thread %ld: %s",
808 (long) GET_THREAD (inferior_pid
), thread_db_err_str (err
));
810 /* Note that we must call supply_gregset after calling the thread_db
811 routines because the thread_db routines call ps_lgetgregs and
812 friends which clobber GDB's register cache. */
813 supply_gregset ((gdb_gregset_t
*) gregset
);
814 supply_fpregset (&fpregset
);
818 thread_db_store_registers (int regno
)
822 gdb_prfpregset_t fpregset
;
825 if (! is_thread (inferior_pid
))
827 /* Pass the request to the target beneath us. */
828 target_beneath
->to_store_registers (regno
);
832 err
= td_ta_map_id2thr_p (thread_agent
, GET_THREAD (inferior_pid
), &th
);
834 error ("Cannot find thread %ld: %s",
835 (long) GET_THREAD (inferior_pid
), thread_db_err_str (err
));
839 char raw
[MAX_REGISTER_RAW_SIZE
];
841 read_register_gen (regno
, raw
);
842 thread_db_fetch_registers (-1);
843 supply_register (regno
, raw
);
846 fill_gregset ((gdb_gregset_t
*) gregset
, -1);
847 fill_fpregset (&fpregset
, -1);
849 err
= td_thr_setgregs_p (&th
, gregset
);
851 error ("Cannot store general-purpose registers for thread %ld: %s",
852 (long) GET_THREAD (inferior_pid
), thread_db_err_str (err
));
853 err
= td_thr_setfpregs_p (&th
, &fpregset
);
855 error ("Cannot store floating-point registers for thread %ld: %s",
856 (long) GET_THREAD (inferior_pid
), thread_db_err_str (err
));
860 thread_db_kill (void)
862 target_beneath
->to_kill ();
866 thread_db_create_inferior (char *exec_file
, char *allargs
, char **env
)
868 target_beneath
->to_create_inferior (exec_file
, allargs
, env
);
872 thread_db_post_startup_inferior (int pid
)
874 if (proc_handle
.pid
== 0)
876 /* The child process is now the actual multi-threaded
877 program. Snatch its process ID... */
878 proc_handle
.pid
= GET_PID (pid
);
880 /* ...and perform the remaining initialization steps. */
881 enable_thread_event_reporting ();
882 thread_db_find_new_threads();
887 thread_db_mourn_inferior (void)
889 remove_thread_event_breakpoints ();
890 deactivate_target ();
892 target_beneath
->to_mourn_inferior ();
896 thread_db_thread_alive (int pid
)
903 err
= td_ta_map_id2thr_p (thread_agent
, GET_THREAD (pid
), &th
);
907 err
= td_thr_validate_p (&th
);
914 if (target_beneath
->to_thread_alive
)
915 return target_beneath
->to_thread_alive (pid
);
921 find_new_threads_callback (const td_thrhandle_t
*th_p
, void *data
)
927 err
= td_thr_get_info_p (th_p
, &ti
);
929 error ("Cannot get thread info: %s", thread_db_err_str (err
));
931 pid
= BUILD_THREAD (ti
.ti_tid
, GET_PID (inferior_pid
));
933 if (! in_thread_list (pid
))
934 attach_thread (pid
, th_p
, &ti
, 1);
940 thread_db_find_new_threads (void)
944 /* Iterate over all user-space threads to discover new threads. */
945 err
= td_ta_thr_iter_p (thread_agent
, find_new_threads_callback
, NULL
,
946 TD_THR_ANY_STATE
, TD_THR_LOWEST_PRIORITY
,
947 TD_SIGNO_MASK
, TD_THR_ANY_USER_FLAGS
);
949 error ("Cannot find new threads: %s", thread_db_err_str (err
));
953 thread_db_pid_to_str (int pid
)
962 err
= td_ta_map_id2thr_p (thread_agent
, GET_THREAD (pid
), &th
);
964 error ("Cannot find thread %ld: %s",
965 (long) GET_THREAD (pid
), thread_db_err_str (err
));
967 err
= td_thr_get_info_p (&th
, &ti
);
969 error ("Cannot get thread info for thread %ld: %s",
970 (long) GET_THREAD (pid
), thread_db_err_str (err
));
972 if (ti
.ti_state
== TD_THR_ACTIVE
&& ti
.ti_lid
!= 0)
974 snprintf (buf
, sizeof (buf
), "Thread %ld (LWP %d)",
975 (long) ti
.ti_tid
, ti
.ti_lid
);
979 snprintf (buf
, sizeof (buf
), "Thread %ld (%s)",
980 (long) ti
.ti_tid
, thread_db_state_str (ti
.ti_state
));
986 if (target_beneath
->to_pid_to_str (pid
))
987 return target_beneath
->to_pid_to_str (pid
);
989 return normal_pid_to_str (pid
);
993 init_thread_db_ops (void)
995 thread_db_ops
.to_shortname
= "multi-thread";
996 thread_db_ops
.to_longname
= "multi-threaded child process.";
997 thread_db_ops
.to_doc
= "Threads and pthreads support.";
998 thread_db_ops
.to_detach
= thread_db_detach
;
999 thread_db_ops
.to_resume
= thread_db_resume
;
1000 thread_db_ops
.to_wait
= thread_db_wait
;
1001 thread_db_ops
.to_fetch_registers
= thread_db_fetch_registers
;
1002 thread_db_ops
.to_store_registers
= thread_db_store_registers
;
1003 thread_db_ops
.to_xfer_memory
= thread_db_xfer_memory
;
1004 thread_db_ops
.to_kill
= thread_db_kill
;
1005 thread_db_ops
.to_create_inferior
= thread_db_create_inferior
;
1006 thread_db_ops
.to_post_startup_inferior
= thread_db_post_startup_inferior
;
1007 thread_db_ops
.to_mourn_inferior
= thread_db_mourn_inferior
;
1008 thread_db_ops
.to_thread_alive
= thread_db_thread_alive
;
1009 thread_db_ops
.to_find_new_threads
= thread_db_find_new_threads
;
1010 thread_db_ops
.to_pid_to_str
= thread_db_pid_to_str
;
1011 thread_db_ops
.to_stratum
= thread_stratum
;
1012 thread_db_ops
.to_has_thread_control
= tc_schedlock
;
1013 thread_db_ops
.to_magic
= OPS_MAGIC
;
1017 _initialize_thread_db (void)
1019 /* Only initialize the module if we can load libthread_db. */
1020 if (thread_db_load ())
1022 init_thread_db_ops ();
1023 add_target (&thread_db_ops
);
1025 /* Add ourselves to objfile event chain. */
1026 target_new_objfile_chain
= target_new_objfile_hook
;
1027 target_new_objfile_hook
= thread_db_new_objfile
;